From 2939c05b190b2c2ac47184a9626001ce1dbdcff0 Mon Sep 17 00:00:00 2001 From: LordMZTE Date: Sun, 23 Apr 2023 16:11:05 +0200 Subject: [PATCH] init --- .gitignore | 1 + LICENSE | 674 + build.zig | 28 + generate_bindings.sh | 28 + nvim_all.h | 171 + nvim_c.zig | 60790 +++++++++++++++++++++++++++++++++++++++++ src/main.zig | 27 + 7 files changed, 61719 insertions(+) create mode 100644 .gitignore create mode 100644 LICENSE create mode 100644 build.zig create mode 100755 generate_bindings.sh create mode 100644 nvim_all.h create mode 100644 nvim_c.zig create mode 100644 src/main.zig diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..fe95f8d --- /dev/null +++ b/.gitignore @@ -0,0 +1 @@ +/zig-* diff --git a/LICENSE b/LICENSE new file mode 100644 index 0000000..f288702 --- /dev/null +++ b/LICENSE @@ -0,0 +1,674 @@ + GNU GENERAL PUBLIC LICENSE + Version 3, 29 June 2007 + + Copyright (C) 2007 Free Software Foundation, Inc. + Everyone is permitted to copy and distribute verbatim copies + of this license document, but changing it is not allowed. + + Preamble + + The GNU General Public License is a free, copyleft license for +software and other kinds of works. + + The licenses for most software and other practical works are designed +to take away your freedom to share and change the works. By contrast, +the GNU General Public License is intended to guarantee your freedom to +share and change all versions of a program--to make sure it remains free +software for all its users. We, the Free Software Foundation, use the +GNU General Public License for most of our software; it applies also to +any other work released this way by its authors. You can apply it to +your programs, too. + + When we speak of free software, we are referring to freedom, not +price. Our General Public Licenses are designed to make sure that you +have the freedom to distribute copies of free software (and charge for +them if you wish), that you receive source code or can get it if you +want it, that you can change the software or use pieces of it in new +free programs, and that you know you can do these things. + + To protect your rights, we need to prevent others from denying you +these rights or asking you to surrender the rights. Therefore, you have +certain responsibilities if you distribute copies of the software, or if +you modify it: responsibilities to respect the freedom of others. + + For example, if you distribute copies of such a program, whether +gratis or for a fee, you must pass on to the recipients the same +freedoms that you received. You must make sure that they, too, receive +or can get the source code. And you must show them these terms so they +know their rights. + + Developers that use the GNU GPL protect your rights with two steps: +(1) assert copyright on the software, and (2) offer you this License +giving you legal permission to copy, distribute and/or modify it. + + For the developers' and authors' protection, the GPL clearly explains +that there is no warranty for this free software. For both users' and +authors' sake, the GPL requires that modified versions be marked as +changed, so that their problems will not be attributed erroneously to +authors of previous versions. + + Some devices are designed to deny users access to install or run +modified versions of the software inside them, although the manufacturer +can do so. This is fundamentally incompatible with the aim of +protecting users' freedom to change the software. The systematic +pattern of such abuse occurs in the area of products for individuals to +use, which is precisely where it is most unacceptable. Therefore, we +have designed this version of the GPL to prohibit the practice for those +products. If such problems arise substantially in other domains, we +stand ready to extend this provision to those domains in future versions +of the GPL, as needed to protect the freedom of users. + + Finally, every program is threatened constantly by software patents. +States should not allow patents to restrict development and use of +software on general-purpose computers, but in those that do, we wish to +avoid the special danger that patents applied to a free program could +make it effectively proprietary. To prevent this, the GPL assures that +patents cannot be used to render the program non-free. + + The precise terms and conditions for copying, distribution and +modification follow. + + TERMS AND CONDITIONS + + 0. Definitions. + + "This License" refers to version 3 of the GNU General Public License. + + "Copyright" also means copyright-like laws that apply to other kinds of +works, such as semiconductor masks. + + "The Program" refers to any copyrightable work licensed under this +License. Each licensee is addressed as "you". "Licensees" and +"recipients" may be individuals or organizations. + + To "modify" a work means to copy from or adapt all or part of the work +in a fashion requiring copyright permission, other than the making of an +exact copy. The resulting work is called a "modified version" of the +earlier work or a work "based on" the earlier work. + + A "covered work" means either the unmodified Program or a work based +on the Program. + + To "propagate" a work means to do anything with it that, without +permission, would make you directly or secondarily liable for +infringement under applicable copyright law, except executing it on a +computer or modifying a private copy. Propagation includes copying, +distribution (with or without modification), making available to the +public, and in some countries other activities as well. + + To "convey" a work means any kind of propagation that enables other +parties to make or receive copies. Mere interaction with a user through +a computer network, with no transfer of a copy, is not conveying. + + An interactive user interface displays "Appropriate Legal Notices" +to the extent that it includes a convenient and prominently visible +feature that (1) displays an appropriate copyright notice, and (2) +tells the user that there is no warranty for the work (except to the +extent that warranties are provided), that licensees may convey the +work under this License, and how to view a copy of this License. If +the interface presents a list of user commands or options, such as a +menu, a prominent item in the list meets this criterion. + + 1. Source Code. + + The "source code" for a work means the preferred form of the work +for making modifications to it. "Object code" means any non-source +form of a work. + + A "Standard Interface" means an interface that either is an official +standard defined by a recognized standards body, or, in the case of +interfaces specified for a particular programming language, one that +is widely used among developers working in that language. + + The "System Libraries" of an executable work include anything, other +than the work as a whole, that (a) is included in the normal form of +packaging a Major Component, but which is not part of that Major +Component, and (b) serves only to enable use of the work with that +Major Component, or to implement a Standard Interface for which an +implementation is available to the public in source code form. A +"Major Component", in this context, means a major essential component +(kernel, window system, and so on) of the specific operating system +(if any) on which the executable work runs, or a compiler used to +produce the work, or an object code interpreter used to run it. + + The "Corresponding Source" for a work in object code form means all +the source code needed to generate, install, and (for an executable +work) run the object code and to modify the work, including scripts to +control those activities. However, it does not include the work's +System Libraries, or general-purpose tools or generally available free +programs which are used unmodified in performing those activities but +which are not part of the work. For example, Corresponding Source +includes interface definition files associated with source files for +the work, and the source code for shared libraries and dynamically +linked subprograms that the work is specifically designed to require, +such as by intimate data communication or control flow between those +subprograms and other parts of the work. + + The Corresponding Source need not include anything that users +can regenerate automatically from other parts of the Corresponding +Source. + + The Corresponding Source for a work in source code form is that +same work. + + 2. Basic Permissions. + + All rights granted under this License are granted for the term of +copyright on the Program, and are irrevocable provided the stated +conditions are met. This License explicitly affirms your unlimited +permission to run the unmodified Program. The output from running a +covered work is covered by this License only if the output, given its +content, constitutes a covered work. This License acknowledges your +rights of fair use or other equivalent, as provided by copyright law. + + You may make, run and propagate covered works that you do not +convey, without conditions so long as your license otherwise remains +in force. You may convey covered works to others for the sole purpose +of having them make modifications exclusively for you, or provide you +with facilities for running those works, provided that you comply with +the terms of this License in conveying all material for which you do +not control copyright. Those thus making or running the covered works +for you must do so exclusively on your behalf, under your direction +and control, on terms that prohibit them from making any copies of +your copyrighted material outside their relationship with you. + + Conveying under any other circumstances is permitted solely under +the conditions stated below. Sublicensing is not allowed; section 10 +makes it unnecessary. + + 3. Protecting Users' Legal Rights From Anti-Circumvention Law. + + No covered work shall be deemed part of an effective technological +measure under any applicable law fulfilling obligations under article +11 of the WIPO copyright treaty adopted on 20 December 1996, or +similar laws prohibiting or restricting circumvention of such +measures. + + When you convey a covered work, you waive any legal power to forbid +circumvention of technological measures to the extent such circumvention +is effected by exercising rights under this License with respect to +the covered work, and you disclaim any intention to limit operation or +modification of the work as a means of enforcing, against the work's +users, your or third parties' legal rights to forbid circumvention of +technological measures. + + 4. Conveying Verbatim Copies. + + You may convey verbatim copies of the Program's source code as you +receive it, in any medium, provided that you conspicuously and +appropriately publish on each copy an appropriate copyright notice; +keep intact all notices stating that this License and any +non-permissive terms added in accord with section 7 apply to the code; +keep intact all notices of the absence of any warranty; and give all +recipients a copy of this License along with the Program. + + You may charge any price or no price for each copy that you convey, +and you may offer support or warranty protection for a fee. + + 5. Conveying Modified Source Versions. + + You may convey a work based on the Program, or the modifications to +produce it from the Program, in the form of source code under the +terms of section 4, provided that you also meet all of these conditions: + + a) The work must carry prominent notices stating that you modified + it, and giving a relevant date. + + b) The work must carry prominent notices stating that it is + released under this License and any conditions added under section + 7. This requirement modifies the requirement in section 4 to + "keep intact all notices". + + c) You must license the entire work, as a whole, under this + License to anyone who comes into possession of a copy. This + License will therefore apply, along with any applicable section 7 + additional terms, to the whole of the work, and all its parts, + regardless of how they are packaged. This License gives no + permission to license the work in any other way, but it does not + invalidate such permission if you have separately received it. + + d) If the work has interactive user interfaces, each must display + Appropriate Legal Notices; however, if the Program has interactive + interfaces that do not display Appropriate Legal Notices, your + work need not make them do so. + + A compilation of a covered work with other separate and independent +works, which are not by their nature extensions of the covered work, +and which are not combined with it such as to form a larger program, +in or on a volume of a storage or distribution medium, is called an +"aggregate" if the compilation and its resulting copyright are not +used to limit the access or legal rights of the compilation's users +beyond what the individual works permit. Inclusion of a covered work +in an aggregate does not cause this License to apply to the other +parts of the aggregate. + + 6. Conveying Non-Source Forms. + + You may convey a covered work in object code form under the terms +of sections 4 and 5, provided that you also convey the +machine-readable Corresponding Source under the terms of this License, +in one of these ways: + + a) Convey the object code in, or embodied in, a physical product + (including a physical distribution medium), accompanied by the + Corresponding Source fixed on a durable physical medium + customarily used for software interchange. + + b) Convey the object code in, or embodied in, a physical product + (including a physical distribution medium), accompanied by a + written offer, valid for at least three years and valid for as + long as you offer spare parts or customer support for that product + model, to give anyone who possesses the object code either (1) a + copy of the Corresponding Source for all the software in the + product that is covered by this License, on a durable physical + medium customarily used for software interchange, for a price no + more than your reasonable cost of physically performing this + conveying of source, or (2) access to copy the + Corresponding Source from a network server at no charge. + + c) Convey individual copies of the object code with a copy of the + written offer to provide the Corresponding Source. This + alternative is allowed only occasionally and noncommercially, and + only if you received the object code with such an offer, in accord + with subsection 6b. + + d) Convey the object code by offering access from a designated + place (gratis or for a charge), and offer equivalent access to the + Corresponding Source in the same way through the same place at no + further charge. You need not require recipients to copy the + Corresponding Source along with the object code. If the place to + copy the object code is a network server, the Corresponding Source + may be on a different server (operated by you or a third party) + that supports equivalent copying facilities, provided you maintain + clear directions next to the object code saying where to find the + Corresponding Source. Regardless of what server hosts the + Corresponding Source, you remain obligated to ensure that it is + available for as long as needed to satisfy these requirements. + + e) Convey the object code using peer-to-peer transmission, provided + you inform other peers where the object code and Corresponding + Source of the work are being offered to the general public at no + charge under subsection 6d. + + A separable portion of the object code, whose source code is excluded +from the Corresponding Source as a System Library, need not be +included in conveying the object code work. + + A "User Product" is either (1) a "consumer product", which means any +tangible personal property which is normally used for personal, family, +or household purposes, or (2) anything designed or sold for incorporation +into a dwelling. In determining whether a product is a consumer product, +doubtful cases shall be resolved in favor of coverage. For a particular +product received by a particular user, "normally used" refers to a +typical or common use of that class of product, regardless of the status +of the particular user or of the way in which the particular user +actually uses, or expects or is expected to use, the product. A product +is a consumer product regardless of whether the product has substantial +commercial, industrial or non-consumer uses, unless such uses represent +the only significant mode of use of the product. + + "Installation Information" for a User Product means any methods, +procedures, authorization keys, or other information required to install +and execute modified versions of a covered work in that User Product from +a modified version of its Corresponding Source. The information must +suffice to ensure that the continued functioning of the modified object +code is in no case prevented or interfered with solely because +modification has been made. + + If you convey an object code work under this section in, or with, or +specifically for use in, a User Product, and the conveying occurs as +part of a transaction in which the right of possession and use of the +User Product is transferred to the recipient in perpetuity or for a +fixed term (regardless of how the transaction is characterized), the +Corresponding Source conveyed under this section must be accompanied +by the Installation Information. But this requirement does not apply +if neither you nor any third party retains the ability to install +modified object code on the User Product (for example, the work has +been installed in ROM). + + The requirement to provide Installation Information does not include a +requirement to continue to provide support service, warranty, or updates +for a work that has been modified or installed by the recipient, or for +the User Product in which it has been modified or installed. Access to a +network may be denied when the modification itself materially and +adversely affects the operation of the network or violates the rules and +protocols for communication across the network. + + Corresponding Source conveyed, and Installation Information provided, +in accord with this section must be in a format that is publicly +documented (and with an implementation available to the public in +source code form), and must require no special password or key for +unpacking, reading or copying. + + 7. Additional Terms. + + "Additional permissions" are terms that supplement the terms of this +License by making exceptions from one or more of its conditions. +Additional permissions that are applicable to the entire Program shall +be treated as though they were included in this License, to the extent +that they are valid under applicable law. If additional permissions +apply only to part of the Program, that part may be used separately +under those permissions, but the entire Program remains governed by +this License without regard to the additional permissions. + + When you convey a copy of a covered work, you may at your option +remove any additional permissions from that copy, or from any part of +it. (Additional permissions may be written to require their own +removal in certain cases when you modify the work.) You may place +additional permissions on material, added by you to a covered work, +for which you have or can give appropriate copyright permission. + + Notwithstanding any other provision of this License, for material you +add to a covered work, you may (if authorized by the copyright holders of +that material) supplement the terms of this License with terms: + + a) Disclaiming warranty or limiting liability differently from the + terms of sections 15 and 16 of this License; or + + b) Requiring preservation of specified reasonable legal notices or + author attributions in that material or in the Appropriate Legal + Notices displayed by works containing it; or + + c) Prohibiting misrepresentation of the origin of that material, or + requiring that modified versions of such material be marked in + reasonable ways as different from the original version; or + + d) Limiting the use for publicity purposes of names of licensors or + authors of the material; or + + e) Declining to grant rights under trademark law for use of some + trade names, trademarks, or service marks; or + + f) Requiring indemnification of licensors and authors of that + material by anyone who conveys the material (or modified versions of + it) with contractual assumptions of liability to the recipient, for + any liability that these contractual assumptions directly impose on + those licensors and authors. + + All other non-permissive additional terms are considered "further +restrictions" within the meaning of section 10. If the Program as you +received it, or any part of it, contains a notice stating that it is +governed by this License along with a term that is a further +restriction, you may remove that term. If a license document contains +a further restriction but permits relicensing or conveying under this +License, you may add to a covered work material governed by the terms +of that license document, provided that the further restriction does +not survive such relicensing or conveying. + + If you add terms to a covered work in accord with this section, you +must place, in the relevant source files, a statement of the +additional terms that apply to those files, or a notice indicating +where to find the applicable terms. + + Additional terms, permissive or non-permissive, may be stated in the +form of a separately written license, or stated as exceptions; +the above requirements apply either way. + + 8. Termination. + + You may not propagate or modify a covered work except as expressly +provided under this License. Any attempt otherwise to propagate or +modify it is void, and will automatically terminate your rights under +this License (including any patent licenses granted under the third +paragraph of section 11). + + However, if you cease all violation of this License, then your +license from a particular copyright holder is reinstated (a) +provisionally, unless and until the copyright holder explicitly and +finally terminates your license, and (b) permanently, if the copyright +holder fails to notify you of the violation by some reasonable means +prior to 60 days after the cessation. + + Moreover, your license from a particular copyright holder is +reinstated permanently if the copyright holder notifies you of the +violation by some reasonable means, this is the first time you have +received notice of violation of this License (for any work) from that +copyright holder, and you cure the violation prior to 30 days after +your receipt of the notice. + + Termination of your rights under this section does not terminate the +licenses of parties who have received copies or rights from you under +this License. If your rights have been terminated and not permanently +reinstated, you do not qualify to receive new licenses for the same +material under section 10. + + 9. Acceptance Not Required for Having Copies. + + You are not required to accept this License in order to receive or +run a copy of the Program. Ancillary propagation of a covered work +occurring solely as a consequence of using peer-to-peer transmission +to receive a copy likewise does not require acceptance. However, +nothing other than this License grants you permission to propagate or +modify any covered work. These actions infringe copyright if you do +not accept this License. Therefore, by modifying or propagating a +covered work, you indicate your acceptance of this License to do so. + + 10. Automatic Licensing of Downstream Recipients. + + Each time you convey a covered work, the recipient automatically +receives a license from the original licensors, to run, modify and +propagate that work, subject to this License. You are not responsible +for enforcing compliance by third parties with this License. + + An "entity transaction" is a transaction transferring control of an +organization, or substantially all assets of one, or subdividing an +organization, or merging organizations. If propagation of a covered +work results from an entity transaction, each party to that +transaction who receives a copy of the work also receives whatever +licenses to the work the party's predecessor in interest had or could +give under the previous paragraph, plus a right to possession of the +Corresponding Source of the work from the predecessor in interest, if +the predecessor has it or can get it with reasonable efforts. + + You may not impose any further restrictions on the exercise of the +rights granted or affirmed under this License. For example, you may +not impose a license fee, royalty, or other charge for exercise of +rights granted under this License, and you may not initiate litigation +(including a cross-claim or counterclaim in a lawsuit) alleging that +any patent claim is infringed by making, using, selling, offering for +sale, or importing the Program or any portion of it. + + 11. Patents. + + A "contributor" is a copyright holder who authorizes use under this +License of the Program or a work on which the Program is based. The +work thus licensed is called the contributor's "contributor version". + + A contributor's "essential patent claims" are all patent claims +owned or controlled by the contributor, whether already acquired or +hereafter acquired, that would be infringed by some manner, permitted +by this License, of making, using, or selling its contributor version, +but do not include claims that would be infringed only as a +consequence of further modification of the contributor version. For +purposes of this definition, "control" includes the right to grant +patent sublicenses in a manner consistent with the requirements of +this License. + + Each contributor grants you a non-exclusive, worldwide, royalty-free +patent license under the contributor's essential patent claims, to +make, use, sell, offer for sale, import and otherwise run, modify and +propagate the contents of its contributor version. + + In the following three paragraphs, a "patent license" is any express +agreement or commitment, however denominated, not to enforce a patent +(such as an express permission to practice a patent or covenant not to +sue for patent infringement). To "grant" such a patent license to a +party means to make such an agreement or commitment not to enforce a +patent against the party. + + If you convey a covered work, knowingly relying on a patent license, +and the Corresponding Source of the work is not available for anyone +to copy, free of charge and under the terms of this License, through a +publicly available network server or other readily accessible means, +then you must either (1) cause the Corresponding Source to be so +available, or (2) arrange to deprive yourself of the benefit of the +patent license for this particular work, or (3) arrange, in a manner +consistent with the requirements of this License, to extend the patent +license to downstream recipients. "Knowingly relying" means you have +actual knowledge that, but for the patent license, your conveying the +covered work in a country, or your recipient's use of the covered work +in a country, would infringe one or more identifiable patents in that +country that you have reason to believe are valid. + + If, pursuant to or in connection with a single transaction or +arrangement, you convey, or propagate by procuring conveyance of, a +covered work, and grant a patent license to some of the parties +receiving the covered work authorizing them to use, propagate, modify +or convey a specific copy of the covered work, then the patent license +you grant is automatically extended to all recipients of the covered +work and works based on it. + + A patent license is "discriminatory" if it does not include within +the scope of its coverage, prohibits the exercise of, or is +conditioned on the non-exercise of one or more of the rights that are +specifically granted under this License. You may not convey a covered +work if you are a party to an arrangement with a third party that is +in the business of distributing software, under which you make payment +to the third party based on the extent of your activity of conveying +the work, and under which the third party grants, to any of the +parties who would receive the covered work from you, a discriminatory +patent license (a) in connection with copies of the covered work +conveyed by you (or copies made from those copies), or (b) primarily +for and in connection with specific products or compilations that +contain the covered work, unless you entered into that arrangement, +or that patent license was granted, prior to 28 March 2007. + + Nothing in this License shall be construed as excluding or limiting +any implied license or other defenses to infringement that may +otherwise be available to you under applicable patent law. + + 12. No Surrender of Others' Freedom. + + If conditions are imposed on you (whether by court order, agreement or +otherwise) that contradict the conditions of this License, they do not +excuse you from the conditions of this License. If you cannot convey a +covered work so as to satisfy simultaneously your obligations under this +License and any other pertinent obligations, then as a consequence you may +not convey it at all. For example, if you agree to terms that obligate you +to collect a royalty for further conveying from those to whom you convey +the Program, the only way you could satisfy both those terms and this +License would be to refrain entirely from conveying the Program. + + 13. Use with the GNU Affero General Public License. + + Notwithstanding any other provision of this License, you have +permission to link or combine any covered work with a work licensed +under version 3 of the GNU Affero General Public License into a single +combined work, and to convey the resulting work. The terms of this +License will continue to apply to the part which is the covered work, +but the special requirements of the GNU Affero General Public License, +section 13, concerning interaction through a network will apply to the +combination as such. + + 14. Revised Versions of this License. + + The Free Software Foundation may publish revised and/or new versions of +the GNU General Public License from time to time. Such new versions will +be similar in spirit to the present version, but may differ in detail to +address new problems or concerns. + + Each version is given a distinguishing version number. If the +Program specifies that a certain numbered version of the GNU General +Public License "or any later version" applies to it, you have the +option of following the terms and conditions either of that numbered +version or of any later version published by the Free Software +Foundation. If the Program does not specify a version number of the +GNU General Public License, you may choose any version ever published +by the Free Software Foundation. + + If the Program specifies that a proxy can decide which future +versions of the GNU General Public License can be used, that proxy's +public statement of acceptance of a version permanently authorizes you +to choose that version for the Program. + + Later license versions may give you additional or different +permissions. However, no additional obligations are imposed on any +author or copyright holder as a result of your choosing to follow a +later version. + + 15. Disclaimer of Warranty. + + THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY +APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT +HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY +OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, +THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR +PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM +IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF +ALL NECESSARY SERVICING, REPAIR OR CORRECTION. + + 16. Limitation of Liability. + + IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING +WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS +THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY +GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE +USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF +DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD +PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), +EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF +SUCH DAMAGES. + + 17. Interpretation of Sections 15 and 16. + + If the disclaimer of warranty and limitation of liability provided +above cannot be given local legal effect according to their terms, +reviewing courts shall apply local law that most closely approximates +an absolute waiver of all civil liability in connection with the +Program, unless a warranty or assumption of liability accompanies a +copy of the Program in return for a fee. + + END OF TERMS AND CONDITIONS + + How to Apply These Terms to Your New Programs + + If you develop a new program, and you want it to be of the greatest +possible use to the public, the best way to achieve this is to make it +free software which everyone can redistribute and change under these terms. + + To do so, attach the following notices to the program. It is safest +to attach them to the start of each source file to most effectively +state the exclusion of warranty; and each file should have at least +the "copyright" line and a pointer to where the full notice is found. + + + Copyright (C) + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . + +Also add information on how to contact you by electronic and paper mail. + + If the program does terminal interaction, make it output a short +notice like this when it starts in an interactive mode: + + Copyright (C) + This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'. + This is free software, and you are welcome to redistribute it + under certain conditions; type `show c' for details. + +The hypothetical commands `show w' and `show c' should show the appropriate +parts of the General Public License. Of course, your program's commands +might be different; for a GUI interface, you would use an "about box". + + You should also get your employer (if you work as a programmer) or school, +if any, to sign a "copyright disclaimer" for the program, if necessary. +For more information on this, and how to apply and follow the GNU GPL, see +. + + The GNU General Public License does not permit incorporating your program +into proprietary programs. If your program is a subroutine library, you +may consider it more useful to permit linking proprietary applications with +the library. If this is what you want to do, use the GNU Lesser General +Public License instead of this License. But first, please read +. diff --git a/build.zig b/build.zig new file mode 100644 index 0000000..e2e4565 --- /dev/null +++ b/build.zig @@ -0,0 +1,28 @@ +const std = @import("std"); + +pub fn build(b: *std.Build) void { + const target = b.standardTargetOptions(.{}); + const optimize = b.standardOptimizeOption(.{}); + + const nvim_c_mod = b.addModule("nvim_c", .{ + .source_file = .{ .path = "nvim_c.zig" }, + }); + + _ = b.addModule("znvim", .{ + .source_file = .{ .path = "src/main.zig" }, + .dependencies = &.{.{ .name = "nvim_c", .module = nvim_c_mod }}, + }); + + const main_tests = b.addTest(.{ + .root_source_file = .{ .path = "src/main.zig" }, + .target = target, + .optimize = optimize, + }); + + main_tests.addModule("nvim_c", nvim_c_mod); + + const run_main_tests = b.addRunArtifact(main_tests); + + const test_step = b.step("test", "Run library tests"); + test_step.dependOn(&run_main_tests.step); +} diff --git a/generate_bindings.sh b/generate_bindings.sh new file mode 100755 index 0000000..75501e2 --- /dev/null +++ b/generate_bindings.sh @@ -0,0 +1,28 @@ +#!/bin/bash +set -ex + +nvimdir="_nvim" +outfile="nvim_c.zig" + +git clone --depth 1 'https://github.com/neovim/neovim.git' $nvimdir + +mkdir $nvimdir/build +pushd $nvimdir/build +# Build required due to tons of generated headers +cmake .. +make -j"$(nproc)" +popd + +echo "// Generated by $0" >$outfile +zig translate-c \ + nvim_all.h \ + -lluajit \ + -I"$nvimdir"/src \ + -I"$nvimdir"/build/src \ + -I"$nvimdir"/build/src/nvim/auto \ + -I"$nvimdir"/build/cmake.config \ + -I"$nvimdir"/build/include \ + -DINCLUDE_GENERATED_DECLARATIONS=1 \ + >>$outfile + +rm -rf $nvimdir diff --git a/nvim_all.h b/nvim_all.h new file mode 100644 index 0000000..dc32cff --- /dev/null +++ b/nvim_all.h @@ -0,0 +1,171 @@ +#include "_nvim/src/nvim/api/autocmd.h" +#include "_nvim/src/nvim/api/buffer.h" +#include "_nvim/src/nvim/api/command.h" +#include "_nvim/src/nvim/api/deprecated.h" +#include "_nvim/src/nvim/api/extmark.h" +#include "_nvim/src/nvim/api/keysets.h" +#include "_nvim/src/nvim/api/options.h" +#include "_nvim/src/nvim/api/tabpage.h" +#include "_nvim/src/nvim/api/ui.h" +#include "_nvim/src/nvim/api/vim.h" +#include "_nvim/src/nvim/api/vimscript.h" +#include "_nvim/src/nvim/api/win_config.h" +#include "_nvim/src/nvim/api/window.h" +#include "_nvim/src/nvim/arabic.h" +#include "_nvim/src/nvim/arglist.h" +#include "_nvim/src/nvim/ascii.h" +#include "_nvim/src/nvim/assert.h" +#include "_nvim/src/nvim/autocmd.h" +#include "_nvim/src/nvim/buffer.h" +#include "_nvim/src/nvim/buffer_defs.h" +#include "_nvim/src/nvim/buffer_updates.h" +#include "_nvim/src/nvim/bufwrite.h" +#include "_nvim/src/nvim/change.h" +#include "_nvim/src/nvim/channel.h" +#include "_nvim/src/nvim/charset.h" +#include "_nvim/src/nvim/cmdexpand.h" +#include "_nvim/src/nvim/cmdhist.h" +#include "_nvim/src/nvim/context.h" +#include "_nvim/src/nvim/cursor.h" +#include "_nvim/src/nvim/cursor_shape.h" +#include "_nvim/src/nvim/debugger.h" +#include "_nvim/src/nvim/decoration.h" +#include "_nvim/src/nvim/decoration_provider.h" +#include "_nvim/src/nvim/diff.h" +#include "_nvim/src/nvim/digraph.h" +#include "_nvim/src/nvim/drawline.h" +#include "_nvim/src/nvim/drawscreen.h" +#include "_nvim/src/nvim/edit.h" +#include "_nvim/src/nvim/event/defs.h" +#include "_nvim/src/nvim/event/libuv_process.h" +#include "_nvim/src/nvim/event/loop.h" +#include "_nvim/src/nvim/event/multiqueue.h" +#include "_nvim/src/nvim/event/process.h" +#include "_nvim/src/nvim/event/rstream.h" +#include "_nvim/src/nvim/event/signal.h" +#include "_nvim/src/nvim/event/socket.h" +#include "_nvim/src/nvim/event/stream.h" +#include "_nvim/src/nvim/event/time.h" +#include "_nvim/src/nvim/event/wstream.h" +#include "_nvim/src/nvim/ex_cmds.h" +#include "_nvim/src/nvim/ex_cmds2.h" +#include "_nvim/src/nvim/ex_cmds_defs.h" +#include "_nvim/src/nvim/ex_docmd.h" +#include "_nvim/src/nvim/ex_eval.h" +#include "_nvim/src/nvim/ex_eval_defs.h" +#include "_nvim/src/nvim/ex_getln.h" +#include "_nvim/src/nvim/ex_session.h" +#include "_nvim/src/nvim/extmark.h" +#include "_nvim/src/nvim/extmark_defs.h" +#include "_nvim/src/nvim/file_search.h" +#include "_nvim/src/nvim/fileio.h" +#include "_nvim/src/nvim/fold.h" +#include "_nvim/src/nvim/fold_defs.h" +#include "_nvim/src/nvim/func_attr.h" +#include "_nvim/src/nvim/garray.h" +#include "_nvim/src/nvim/getchar.h" +#include "_nvim/src/nvim/gettext.h" +#include "_nvim/src/nvim/globals.h" +#include "_nvim/src/nvim/grid.h" +#include "_nvim/src/nvim/grid_defs.h" +#include "_nvim/src/nvim/hashtab.h" +#include "_nvim/src/nvim/help.h" +#include "_nvim/src/nvim/highlight.h" +#include "_nvim/src/nvim/highlight_defs.h" +#include "_nvim/src/nvim/highlight_group.h" +#include "_nvim/src/nvim/iconv.h" +#include "_nvim/src/nvim/indent.h" +#include "_nvim/src/nvim/indent_c.h" +#include "_nvim/src/nvim/input.h" +#include "_nvim/src/nvim/insexpand.h" +#include "_nvim/src/nvim/keycodes.h" +#include "_nvim/src/nvim/lib/queue.h" +#include "_nvim/src/nvim/lib/ringbuf.h" +#include "_nvim/src/nvim/linematch.h" +#include "_nvim/src/nvim/log.h" +#include "_nvim/src/nvim/lua/converter.h" +#include "_nvim/src/nvim/lua/executor.h" +#include "_nvim/src/nvim/lua/spell.h" +#include "_nvim/src/nvim/lua/stdlib.h" +#include "_nvim/src/nvim/lua/treesitter.h" +#include "_nvim/src/nvim/lua/xdiff.h" +#include "_nvim/src/nvim/macros.h" +#include "_nvim/src/nvim/main.h" +#include "_nvim/src/nvim/map.h" +#include "_nvim/src/nvim/map_defs.h" +#include "_nvim/src/nvim/mapping.h" +#include "_nvim/src/nvim/mark.h" +#include "_nvim/src/nvim/mark_defs.h" +#include "_nvim/src/nvim/marktree.h" +#include "_nvim/src/nvim/match.h" +#include "_nvim/src/nvim/math.h" +#include "_nvim/src/nvim/mbyte.h" +#include "_nvim/src/nvim/mbyte_defs.h" +#include "_nvim/src/nvim/memfile.h" +#include "_nvim/src/nvim/memfile_defs.h" +#include "_nvim/src/nvim/memline.h" +#include "_nvim/src/nvim/memline_defs.h" +#include "_nvim/src/nvim/memory.h" +#include "_nvim/src/nvim/menu.h" +#include "_nvim/src/nvim/menu_defs.h" +#include "_nvim/src/nvim/message.h" +#include "_nvim/src/nvim/mouse.h" +#include "_nvim/src/nvim/move.h" +#include "_nvim/src/nvim/msgpack_rpc/channel.h" +#include "_nvim/src/nvim/msgpack_rpc/channel_defs.h" +#include "_nvim/src/nvim/msgpack_rpc/helpers.h" +#include "_nvim/src/nvim/msgpack_rpc/server.h" +#include "_nvim/src/nvim/msgpack_rpc/unpacker.h" +#include "_nvim/src/nvim/normal.h" +#include "_nvim/src/nvim/ops.h" +#include "_nvim/src/nvim/option.h" +#include "_nvim/src/nvim/option_defs.h" +#include "_nvim/src/nvim/optionstr.h" +#include "_nvim/src/nvim/path.h" +#include "_nvim/src/nvim/plines.h" +#include "_nvim/src/nvim/popupmenu.h" +#include "_nvim/src/nvim/pos.h" +#include "_nvim/src/nvim/profile.h" +#include "_nvim/src/nvim/quickfix.h" +#include "_nvim/src/nvim/rbuffer.h" +#include "_nvim/src/nvim/regexp.h" +#include "_nvim/src/nvim/regexp_defs.h" +#include "_nvim/src/nvim/runtime.h" +#include "_nvim/src/nvim/search.h" +#include "_nvim/src/nvim/sha256.h" +#include "_nvim/src/nvim/shada.h" +#include "_nvim/src/nvim/sign.h" +#include "_nvim/src/nvim/sign_defs.h" +#include "_nvim/src/nvim/spell.h" +#include "_nvim/src/nvim/spell_defs.h" +#include "_nvim/src/nvim/spellfile.h" +#include "_nvim/src/nvim/spellsuggest.h" +#include "_nvim/src/nvim/state.h" +#include "_nvim/src/nvim/statusline.h" +#include "_nvim/src/nvim/statusline_defs.h" +#include "_nvim/src/nvim/strings.h" +#include "_nvim/src/nvim/syntax.h" +#include "_nvim/src/nvim/syntax_defs.h" +#include "_nvim/src/nvim/tag.h" +#include "_nvim/src/nvim/terminal.h" +#include "_nvim/src/nvim/testing.h" +#include "_nvim/src/nvim/textformat.h" +#include "_nvim/src/nvim/textobject.h" +#include "_nvim/src/nvim/tui/input.h" +#include "_nvim/src/nvim/tui/input_defs.h" +#include "_nvim/src/nvim/tui/terminfo.h" +#include "_nvim/src/nvim/tui/terminfo_defs.h" +#include "_nvim/src/nvim/tui/tui.h" +#include "_nvim/src/nvim/types.h" +#include "_nvim/src/nvim/ugrid.h" +#include "_nvim/src/nvim/ui.h" +#include "_nvim/src/nvim/ui_client.h" +#include "_nvim/src/nvim/ui_compositor.h" +#include "_nvim/src/nvim/undo.h" +#include "_nvim/src/nvim/undo_defs.h" +#include "_nvim/src/nvim/usercmd.h" +#include "_nvim/src/nvim/version.h" +#include "_nvim/src/nvim/vim.h" +#include "_nvim/src/nvim/viml/parser/expressions.h" +#include "_nvim/src/nvim/viml/parser/parser.h" +#include "_nvim/src/nvim/window.h" diff --git a/nvim_c.zig b/nvim_c.zig new file mode 100644 index 0000000..e9633a9 --- /dev/null +++ b/nvim_c.zig @@ -0,0 +1,60790 @@ +// Generated by ./generate_bindings.sh +pub const __builtin_bswap16 = @import("std").zig.c_builtins.__builtin_bswap16; +pub const __builtin_bswap32 = @import("std").zig.c_builtins.__builtin_bswap32; +pub const __builtin_bswap64 = @import("std").zig.c_builtins.__builtin_bswap64; +pub const __builtin_signbit = @import("std").zig.c_builtins.__builtin_signbit; +pub const __builtin_signbitf = @import("std").zig.c_builtins.__builtin_signbitf; +pub const __builtin_popcount = @import("std").zig.c_builtins.__builtin_popcount; +pub const __builtin_ctz = @import("std").zig.c_builtins.__builtin_ctz; +pub const __builtin_clz = @import("std").zig.c_builtins.__builtin_clz; +pub const __builtin_sqrt = @import("std").zig.c_builtins.__builtin_sqrt; +pub const __builtin_sqrtf = @import("std").zig.c_builtins.__builtin_sqrtf; +pub const __builtin_sin = @import("std").zig.c_builtins.__builtin_sin; +pub const __builtin_sinf = @import("std").zig.c_builtins.__builtin_sinf; +pub const __builtin_cos = @import("std").zig.c_builtins.__builtin_cos; +pub const __builtin_cosf = @import("std").zig.c_builtins.__builtin_cosf; +pub const __builtin_exp = @import("std").zig.c_builtins.__builtin_exp; +pub const __builtin_expf = @import("std").zig.c_builtins.__builtin_expf; +pub const __builtin_exp2 = @import("std").zig.c_builtins.__builtin_exp2; +pub const __builtin_exp2f = @import("std").zig.c_builtins.__builtin_exp2f; +pub const __builtin_log = @import("std").zig.c_builtins.__builtin_log; +pub const __builtin_logf = @import("std").zig.c_builtins.__builtin_logf; +pub const __builtin_log2 = @import("std").zig.c_builtins.__builtin_log2; +pub const __builtin_log2f = @import("std").zig.c_builtins.__builtin_log2f; +pub const __builtin_log10 = @import("std").zig.c_builtins.__builtin_log10; +pub const __builtin_log10f = @import("std").zig.c_builtins.__builtin_log10f; +pub const __builtin_abs = @import("std").zig.c_builtins.__builtin_abs; +pub const __builtin_fabs = @import("std").zig.c_builtins.__builtin_fabs; +pub const __builtin_fabsf = @import("std").zig.c_builtins.__builtin_fabsf; +pub const __builtin_floor = @import("std").zig.c_builtins.__builtin_floor; +pub const __builtin_floorf = @import("std").zig.c_builtins.__builtin_floorf; +pub const __builtin_ceil = @import("std").zig.c_builtins.__builtin_ceil; +pub const __builtin_ceilf = @import("std").zig.c_builtins.__builtin_ceilf; +pub const __builtin_trunc = @import("std").zig.c_builtins.__builtin_trunc; +pub const __builtin_truncf = @import("std").zig.c_builtins.__builtin_truncf; +pub const __builtin_round = @import("std").zig.c_builtins.__builtin_round; +pub const __builtin_roundf = @import("std").zig.c_builtins.__builtin_roundf; +pub const __builtin_strlen = @import("std").zig.c_builtins.__builtin_strlen; +pub const __builtin_strcmp = @import("std").zig.c_builtins.__builtin_strcmp; +pub const __builtin_object_size = @import("std").zig.c_builtins.__builtin_object_size; +pub const __builtin___memset_chk = @import("std").zig.c_builtins.__builtin___memset_chk; +pub const __builtin_memset = @import("std").zig.c_builtins.__builtin_memset; +pub const __builtin___memcpy_chk = @import("std").zig.c_builtins.__builtin___memcpy_chk; +pub const __builtin_memcpy = @import("std").zig.c_builtins.__builtin_memcpy; +pub const __builtin_expect = @import("std").zig.c_builtins.__builtin_expect; +pub const __builtin_nanf = @import("std").zig.c_builtins.__builtin_nanf; +pub const __builtin_huge_valf = @import("std").zig.c_builtins.__builtin_huge_valf; +pub const __builtin_inff = @import("std").zig.c_builtins.__builtin_inff; +pub const __builtin_isnan = @import("std").zig.c_builtins.__builtin_isnan; +pub const __builtin_isinf = @import("std").zig.c_builtins.__builtin_isinf; +pub const __builtin_isinf_sign = @import("std").zig.c_builtins.__builtin_isinf_sign; +pub const __has_builtin = @import("std").zig.c_builtins.__has_builtin; +pub const __builtin_assume = @import("std").zig.c_builtins.__builtin_assume; +pub const __builtin_unreachable = @import("std").zig.c_builtins.__builtin_unreachable; +pub const __builtin_constant_p = @import("std").zig.c_builtins.__builtin_constant_p; +pub const __builtin_mul_overflow = @import("std").zig.c_builtins.__builtin_mul_overflow; +pub const __u_char = u8; +pub const __u_short = c_ushort; +pub const __u_int = c_uint; +pub const __u_long = c_ulong; +pub const __int8_t = i8; +pub const __uint8_t = u8; +pub const __int16_t = c_short; +pub const __uint16_t = c_ushort; +pub const __int32_t = c_int; +pub const __uint32_t = c_uint; +pub const __int64_t = c_long; +pub const __uint64_t = c_ulong; +pub const __int_least8_t = __int8_t; +pub const __uint_least8_t = __uint8_t; +pub const __int_least16_t = __int16_t; +pub const __uint_least16_t = __uint16_t; +pub const __int_least32_t = __int32_t; +pub const __uint_least32_t = __uint32_t; +pub const __int_least64_t = __int64_t; +pub const __uint_least64_t = __uint64_t; +pub const __quad_t = c_long; +pub const __u_quad_t = c_ulong; +pub const __intmax_t = c_long; +pub const __uintmax_t = c_ulong; +pub const __dev_t = c_ulong; +pub const __uid_t = c_uint; +pub const __gid_t = c_uint; +pub const __ino_t = c_ulong; +pub const __ino64_t = c_ulong; +pub const __mode_t = c_uint; +pub const __nlink_t = c_ulong; +pub const __off_t = c_long; +pub const __off64_t = c_long; +pub const __pid_t = c_int; +pub const __fsid_t = extern struct { + __val: [2]c_int, +}; +pub const __clock_t = c_long; +pub const __rlim_t = c_ulong; +pub const __rlim64_t = c_ulong; +pub const __id_t = c_uint; +pub const __time_t = c_long; +pub const __useconds_t = c_uint; +pub const __suseconds_t = c_long; +pub const __suseconds64_t = c_long; +pub const __daddr_t = c_int; +pub const __key_t = c_int; +pub const __clockid_t = c_int; +pub const __timer_t = ?*anyopaque; +pub const __blksize_t = c_long; +pub const __blkcnt_t = c_long; +pub const __blkcnt64_t = c_long; +pub const __fsblkcnt_t = c_ulong; +pub const __fsblkcnt64_t = c_ulong; +pub const __fsfilcnt_t = c_ulong; +pub const __fsfilcnt64_t = c_ulong; +pub const __fsword_t = c_long; +pub const __ssize_t = c_long; +pub const __syscall_slong_t = c_long; +pub const __syscall_ulong_t = c_ulong; +pub const __loff_t = __off64_t; +pub const __caddr_t = [*c]u8; +pub const __intptr_t = c_long; +pub const __socklen_t = c_uint; +pub const __sig_atomic_t = c_int; +pub const int_least8_t = __int_least8_t; +pub const int_least16_t = __int_least16_t; +pub const int_least32_t = __int_least32_t; +pub const int_least64_t = __int_least64_t; +pub const uint_least8_t = __uint_least8_t; +pub const uint_least16_t = __uint_least16_t; +pub const uint_least32_t = __uint_least32_t; +pub const uint_least64_t = __uint_least64_t; +pub const int_fast8_t = i8; +pub const int_fast16_t = c_long; +pub const int_fast32_t = c_long; +pub const int_fast64_t = c_long; +pub const uint_fast8_t = u8; +pub const uint_fast16_t = c_ulong; +pub const uint_fast32_t = c_ulong; +pub const uint_fast64_t = c_ulong; +pub const intmax_t = __intmax_t; +pub const uintmax_t = __uintmax_t; +pub extern fn memcpy(__dest: ?*anyopaque, __src: ?*const anyopaque, __n: c_ulong) ?*anyopaque; +pub extern fn memmove(__dest: ?*anyopaque, __src: ?*const anyopaque, __n: c_ulong) ?*anyopaque; +pub extern fn memccpy(__dest: ?*anyopaque, __src: ?*const anyopaque, __c: c_int, __n: c_ulong) ?*anyopaque; +pub extern fn memset(__s: ?*anyopaque, __c: c_int, __n: c_ulong) ?*anyopaque; +pub extern fn memcmp(__s1: ?*const anyopaque, __s2: ?*const anyopaque, __n: c_ulong) c_int; +pub extern fn __memcmpeq(__s1: ?*const anyopaque, __s2: ?*const anyopaque, __n: usize) c_int; +pub extern fn memchr(__s: ?*const anyopaque, __c: c_int, __n: c_ulong) ?*anyopaque; +pub extern fn strcpy(__dest: [*c]u8, __src: [*c]const u8) [*c]u8; +pub extern fn strncpy(__dest: [*c]u8, __src: [*c]const u8, __n: c_ulong) [*c]u8; +pub extern fn strcat(__dest: [*c]u8, __src: [*c]const u8) [*c]u8; +pub extern fn strncat(__dest: [*c]u8, __src: [*c]const u8, __n: c_ulong) [*c]u8; +pub extern fn strcmp(__s1: [*c]const u8, __s2: [*c]const u8) c_int; +pub extern fn strncmp(__s1: [*c]const u8, __s2: [*c]const u8, __n: c_ulong) c_int; +pub extern fn strcoll(__s1: [*c]const u8, __s2: [*c]const u8) c_int; +pub extern fn strxfrm(__dest: [*c]u8, __src: [*c]const u8, __n: c_ulong) c_ulong; +pub const struct___locale_data = opaque {}; +pub const struct___locale_struct = extern struct { + __locales: [13]?*struct___locale_data, + __ctype_b: [*c]const c_ushort, + __ctype_tolower: [*c]const c_int, + __ctype_toupper: [*c]const c_int, + __names: [13][*c]const u8, +}; +pub const __locale_t = [*c]struct___locale_struct; +pub const locale_t = __locale_t; +pub extern fn strcoll_l(__s1: [*c]const u8, __s2: [*c]const u8, __l: locale_t) c_int; +pub extern fn strxfrm_l(__dest: [*c]u8, __src: [*c]const u8, __n: usize, __l: locale_t) usize; +pub extern fn strdup(__s: [*c]const u8) [*c]u8; +pub extern fn strndup(__string: [*c]const u8, __n: c_ulong) [*c]u8; +pub extern fn strchr(__s: [*c]const u8, __c: c_int) [*c]u8; +pub extern fn strrchr(__s: [*c]const u8, __c: c_int) [*c]u8; +pub extern fn strcspn(__s: [*c]const u8, __reject: [*c]const u8) c_ulong; +pub extern fn strspn(__s: [*c]const u8, __accept: [*c]const u8) c_ulong; +pub extern fn strpbrk(__s: [*c]const u8, __accept: [*c]const u8) [*c]u8; +pub extern fn strstr(__haystack: [*c]const u8, __needle: [*c]const u8) [*c]u8; +pub extern fn strtok(__s: [*c]u8, __delim: [*c]const u8) [*c]u8; +pub extern fn __strtok_r(noalias __s: [*c]u8, noalias __delim: [*c]const u8, noalias __save_ptr: [*c][*c]u8) [*c]u8; +pub extern fn strtok_r(noalias __s: [*c]u8, noalias __delim: [*c]const u8, noalias __save_ptr: [*c][*c]u8) [*c]u8; +pub extern fn strlen(__s: [*c]const u8) c_ulong; +pub extern fn strnlen(__string: [*c]const u8, __maxlen: usize) usize; +pub extern fn strerror(__errnum: c_int) [*c]u8; +pub extern fn strerror_r(__errnum: c_int, __buf: [*c]u8, __buflen: usize) c_int; +pub extern fn strerror_l(__errnum: c_int, __l: locale_t) [*c]u8; +pub extern fn bcmp(__s1: ?*const anyopaque, __s2: ?*const anyopaque, __n: c_ulong) c_int; +pub extern fn bcopy(__src: ?*const anyopaque, __dest: ?*anyopaque, __n: usize) void; +pub extern fn bzero(__s: ?*anyopaque, __n: c_ulong) void; +pub extern fn index(__s: [*c]const u8, __c: c_int) [*c]u8; +pub extern fn rindex(__s: [*c]const u8, __c: c_int) [*c]u8; +pub extern fn ffs(__i: c_int) c_int; +pub extern fn ffsl(__l: c_long) c_int; +pub extern fn ffsll(__ll: c_longlong) c_int; +pub extern fn strcasecmp(__s1: [*c]const u8, __s2: [*c]const u8) c_int; +pub extern fn strncasecmp(__s1: [*c]const u8, __s2: [*c]const u8, __n: c_ulong) c_int; +pub extern fn strcasecmp_l(__s1: [*c]const u8, __s2: [*c]const u8, __loc: locale_t) c_int; +pub extern fn strncasecmp_l(__s1: [*c]const u8, __s2: [*c]const u8, __n: usize, __loc: locale_t) c_int; +pub extern fn explicit_bzero(__s: ?*anyopaque, __n: usize) void; +pub extern fn strsep(noalias __stringp: [*c][*c]u8, noalias __delim: [*c]const u8) [*c]u8; +pub extern fn strsignal(__sig: c_int) [*c]u8; +pub extern fn __stpcpy(noalias __dest: [*c]u8, noalias __src: [*c]const u8) [*c]u8; +pub extern fn stpcpy(__dest: [*c]u8, __src: [*c]const u8) [*c]u8; +pub extern fn __stpncpy(noalias __dest: [*c]u8, noalias __src: [*c]const u8, __n: usize) [*c]u8; +pub extern fn stpncpy(__dest: [*c]u8, __src: [*c]const u8, __n: c_ulong) [*c]u8; +pub const wchar_t = c_int; +pub const _Float32 = f32; +pub const _Float64 = f64; +pub const _Float32x = f64; +pub const _Float64x = c_longdouble; +pub const div_t = extern struct { + quot: c_int, + rem: c_int, +}; +pub const ldiv_t = extern struct { + quot: c_long, + rem: c_long, +}; +pub const lldiv_t = extern struct { + quot: c_longlong, + rem: c_longlong, +}; +pub extern fn __ctype_get_mb_cur_max() usize; +pub extern fn atof(__nptr: [*c]const u8) f64; +pub extern fn atoi(__nptr: [*c]const u8) c_int; +pub extern fn atol(__nptr: [*c]const u8) c_long; +pub extern fn atoll(__nptr: [*c]const u8) c_longlong; +pub extern fn strtod(__nptr: [*c]const u8, __endptr: [*c][*c]u8) f64; +pub extern fn strtof(__nptr: [*c]const u8, __endptr: [*c][*c]u8) f32; +pub extern fn strtold(__nptr: [*c]const u8, __endptr: [*c][*c]u8) c_longdouble; +pub extern fn strtol(__nptr: [*c]const u8, __endptr: [*c][*c]u8, __base: c_int) c_long; +pub extern fn strtoul(__nptr: [*c]const u8, __endptr: [*c][*c]u8, __base: c_int) c_ulong; +pub extern fn strtoq(noalias __nptr: [*c]const u8, noalias __endptr: [*c][*c]u8, __base: c_int) c_longlong; +pub extern fn strtouq(noalias __nptr: [*c]const u8, noalias __endptr: [*c][*c]u8, __base: c_int) c_ulonglong; +pub extern fn strtoll(__nptr: [*c]const u8, __endptr: [*c][*c]u8, __base: c_int) c_longlong; +pub extern fn strtoull(__nptr: [*c]const u8, __endptr: [*c][*c]u8, __base: c_int) c_ulonglong; +pub extern fn l64a(__n: c_long) [*c]u8; +pub extern fn a64l(__s: [*c]const u8) c_long; +pub const u_char = __u_char; +pub const u_short = __u_short; +pub const u_int = __u_int; +pub const u_long = __u_long; +pub const quad_t = __quad_t; +pub const u_quad_t = __u_quad_t; +pub const fsid_t = __fsid_t; +pub const loff_t = __loff_t; +pub const ino_t = __ino_t; +pub const dev_t = __dev_t; +pub const gid_t = __gid_t; +pub const mode_t = __mode_t; +pub const nlink_t = __nlink_t; +pub const uid_t = __uid_t; +pub const off_t = __off_t; +pub const pid_t = __pid_t; +pub const id_t = __id_t; +pub const daddr_t = __daddr_t; +pub const caddr_t = __caddr_t; +pub const key_t = __key_t; +pub const clock_t = __clock_t; +pub const clockid_t = __clockid_t; +pub const time_t = __time_t; +pub const timer_t = __timer_t; +pub const ulong = c_ulong; +pub const ushort = c_ushort; +pub const uint = c_uint; +pub const u_int8_t = __uint8_t; +pub const u_int16_t = __uint16_t; +pub const u_int32_t = __uint32_t; +pub const u_int64_t = __uint64_t; +pub const register_t = c_long; +pub fn __bswap_16(arg___bsx: __uint16_t) callconv(.C) __uint16_t { + var __bsx = arg___bsx; + return @bitCast(__uint16_t, @truncate(c_short, ((@bitCast(c_int, @as(c_uint, __bsx)) >> @intCast(@import("std").math.Log2Int(c_int), 8)) & @as(c_int, 255)) | ((@bitCast(c_int, @as(c_uint, __bsx)) & @as(c_int, 255)) << @intCast(@import("std").math.Log2Int(c_int), 8)))); +} +pub fn __bswap_32(arg___bsx: __uint32_t) callconv(.C) __uint32_t { + var __bsx = arg___bsx; + return ((((__bsx & @as(c_uint, 4278190080)) >> @intCast(@import("std").math.Log2Int(c_uint), 24)) | ((__bsx & @as(c_uint, 16711680)) >> @intCast(@import("std").math.Log2Int(c_uint), 8))) | ((__bsx & @as(c_uint, 65280)) << @intCast(@import("std").math.Log2Int(c_uint), 8))) | ((__bsx & @as(c_uint, 255)) << @intCast(@import("std").math.Log2Int(c_uint), 24)); +} +pub fn __bswap_64(arg___bsx: __uint64_t) callconv(.C) __uint64_t { + var __bsx = arg___bsx; + return @bitCast(__uint64_t, @truncate(c_ulong, ((((((((@bitCast(c_ulonglong, @as(c_ulonglong, __bsx)) & @as(c_ulonglong, 18374686479671623680)) >> @intCast(@import("std").math.Log2Int(c_ulonglong), 56)) | ((@bitCast(c_ulonglong, @as(c_ulonglong, __bsx)) & @as(c_ulonglong, 71776119061217280)) >> @intCast(@import("std").math.Log2Int(c_ulonglong), 40))) | ((@bitCast(c_ulonglong, @as(c_ulonglong, __bsx)) & @as(c_ulonglong, 280375465082880)) >> @intCast(@import("std").math.Log2Int(c_ulonglong), 24))) | ((@bitCast(c_ulonglong, @as(c_ulonglong, __bsx)) & @as(c_ulonglong, 1095216660480)) >> @intCast(@import("std").math.Log2Int(c_ulonglong), 8))) | ((@bitCast(c_ulonglong, @as(c_ulonglong, __bsx)) & @as(c_ulonglong, 4278190080)) << @intCast(@import("std").math.Log2Int(c_ulonglong), 8))) | ((@bitCast(c_ulonglong, @as(c_ulonglong, __bsx)) & @as(c_ulonglong, 16711680)) << @intCast(@import("std").math.Log2Int(c_ulonglong), 24))) | ((@bitCast(c_ulonglong, @as(c_ulonglong, __bsx)) & @as(c_ulonglong, 65280)) << @intCast(@import("std").math.Log2Int(c_ulonglong), 40))) | ((@bitCast(c_ulonglong, @as(c_ulonglong, __bsx)) & @as(c_ulonglong, 255)) << @intCast(@import("std").math.Log2Int(c_ulonglong), 56)))); +} +pub fn __uint16_identity(arg___x: __uint16_t) callconv(.C) __uint16_t { + var __x = arg___x; + return __x; +} +pub fn __uint32_identity(arg___x: __uint32_t) callconv(.C) __uint32_t { + var __x = arg___x; + return __x; +} +pub fn __uint64_identity(arg___x: __uint64_t) callconv(.C) __uint64_t { + var __x = arg___x; + return __x; +} +pub const __sigset_t = extern struct { + __val: [16]c_ulong, +}; +pub const sigset_t = __sigset_t; +pub const struct_timeval = extern struct { + tv_sec: __time_t, + tv_usec: __suseconds_t, +}; +pub const struct_timespec = extern struct { + tv_sec: __time_t, + tv_nsec: __syscall_slong_t, +}; +pub const suseconds_t = __suseconds_t; +pub const __fd_mask = c_long; +pub const fd_set = extern struct { + __fds_bits: [16]__fd_mask, +}; +pub const fd_mask = __fd_mask; +pub extern fn select(__nfds: c_int, noalias __readfds: [*c]fd_set, noalias __writefds: [*c]fd_set, noalias __exceptfds: [*c]fd_set, noalias __timeout: [*c]struct_timeval) c_int; +pub extern fn pselect(__nfds: c_int, noalias __readfds: [*c]fd_set, noalias __writefds: [*c]fd_set, noalias __exceptfds: [*c]fd_set, noalias __timeout: [*c]const struct_timespec, noalias __sigmask: [*c]const __sigset_t) c_int; +pub const blksize_t = __blksize_t; +pub const blkcnt_t = __blkcnt_t; +pub const fsblkcnt_t = __fsblkcnt_t; +pub const fsfilcnt_t = __fsfilcnt_t; +const struct_unnamed_1 = extern struct { + __low: c_uint, + __high: c_uint, +}; +pub const __atomic_wide_counter = extern union { + __value64: c_ulonglong, + __value32: struct_unnamed_1, +}; +pub const struct___pthread_internal_list = extern struct { + __prev: [*c]struct___pthread_internal_list, + __next: [*c]struct___pthread_internal_list, +}; +pub const __pthread_list_t = struct___pthread_internal_list; +pub const struct___pthread_internal_slist = extern struct { + __next: [*c]struct___pthread_internal_slist, +}; +pub const __pthread_slist_t = struct___pthread_internal_slist; +pub const struct___pthread_mutex_s = extern struct { + __lock: c_int, + __count: c_uint, + __owner: c_int, + __nusers: c_uint, + __kind: c_int, + __spins: c_short, + __elision: c_short, + __list: __pthread_list_t, +}; +pub const struct___pthread_rwlock_arch_t = extern struct { + __readers: c_uint, + __writers: c_uint, + __wrphase_futex: c_uint, + __writers_futex: c_uint, + __pad3: c_uint, + __pad4: c_uint, + __cur_writer: c_int, + __shared: c_int, + __rwelision: i8, + __pad1: [7]u8, + __pad2: c_ulong, + __flags: c_uint, +}; +pub const struct___pthread_cond_s = extern struct { + __wseq: __atomic_wide_counter, + __g1_start: __atomic_wide_counter, + __g_refs: [2]c_uint, + __g_size: [2]c_uint, + __g1_orig_size: c_uint, + __wrefs: c_uint, + __g_signals: [2]c_uint, +}; +pub const __tss_t = c_uint; +pub const __thrd_t = c_ulong; +pub const __once_flag = extern struct { + __data: c_int, +}; +pub const pthread_t = c_ulong; +pub const pthread_mutexattr_t = extern union { + __size: [4]u8, + __align: c_int, +}; +pub const pthread_condattr_t = extern union { + __size: [4]u8, + __align: c_int, +}; +pub const pthread_key_t = c_uint; +pub const pthread_once_t = c_int; +pub const union_pthread_attr_t = extern union { + __size: [56]u8, + __align: c_long, +}; +pub const pthread_attr_t = union_pthread_attr_t; +pub const pthread_mutex_t = extern union { + __data: struct___pthread_mutex_s, + __size: [40]u8, + __align: c_long, +}; +pub const pthread_cond_t = extern union { + __data: struct___pthread_cond_s, + __size: [48]u8, + __align: c_longlong, +}; +pub const pthread_rwlock_t = extern union { + __data: struct___pthread_rwlock_arch_t, + __size: [56]u8, + __align: c_long, +}; +pub const pthread_rwlockattr_t = extern union { + __size: [8]u8, + __align: c_long, +}; +pub const pthread_spinlock_t = c_int; +pub const pthread_barrier_t = extern union { + __size: [32]u8, + __align: c_long, +}; +pub const pthread_barrierattr_t = extern union { + __size: [4]u8, + __align: c_int, +}; +pub extern fn random() c_long; +pub extern fn srandom(__seed: c_uint) void; +pub extern fn initstate(__seed: c_uint, __statebuf: [*c]u8, __statelen: usize) [*c]u8; +pub extern fn setstate(__statebuf: [*c]u8) [*c]u8; +pub const struct_random_data = extern struct { + fptr: [*c]i32, + rptr: [*c]i32, + state: [*c]i32, + rand_type: c_int, + rand_deg: c_int, + rand_sep: c_int, + end_ptr: [*c]i32, +}; +pub extern fn random_r(noalias __buf: [*c]struct_random_data, noalias __result: [*c]i32) c_int; +pub extern fn srandom_r(__seed: c_uint, __buf: [*c]struct_random_data) c_int; +pub extern fn initstate_r(__seed: c_uint, noalias __statebuf: [*c]u8, __statelen: usize, noalias __buf: [*c]struct_random_data) c_int; +pub extern fn setstate_r(noalias __statebuf: [*c]u8, noalias __buf: [*c]struct_random_data) c_int; +pub extern fn rand() c_int; +pub extern fn srand(__seed: c_uint) void; +pub extern fn rand_r(__seed: [*c]c_uint) c_int; +pub extern fn drand48() f64; +pub extern fn erand48(__xsubi: [*c]c_ushort) f64; +pub extern fn lrand48() c_long; +pub extern fn nrand48(__xsubi: [*c]c_ushort) c_long; +pub extern fn mrand48() c_long; +pub extern fn jrand48(__xsubi: [*c]c_ushort) c_long; +pub extern fn srand48(__seedval: c_long) void; +pub extern fn seed48(__seed16v: [*c]c_ushort) [*c]c_ushort; +pub extern fn lcong48(__param: [*c]c_ushort) void; +pub const struct_drand48_data = extern struct { + __x: [3]c_ushort, + __old_x: [3]c_ushort, + __c: c_ushort, + __init: c_ushort, + __a: c_ulonglong, +}; +pub extern fn drand48_r(noalias __buffer: [*c]struct_drand48_data, noalias __result: [*c]f64) c_int; +pub extern fn erand48_r(__xsubi: [*c]c_ushort, noalias __buffer: [*c]struct_drand48_data, noalias __result: [*c]f64) c_int; +pub extern fn lrand48_r(noalias __buffer: [*c]struct_drand48_data, noalias __result: [*c]c_long) c_int; +pub extern fn nrand48_r(__xsubi: [*c]c_ushort, noalias __buffer: [*c]struct_drand48_data, noalias __result: [*c]c_long) c_int; +pub extern fn mrand48_r(noalias __buffer: [*c]struct_drand48_data, noalias __result: [*c]c_long) c_int; +pub extern fn jrand48_r(__xsubi: [*c]c_ushort, noalias __buffer: [*c]struct_drand48_data, noalias __result: [*c]c_long) c_int; +pub extern fn srand48_r(__seedval: c_long, __buffer: [*c]struct_drand48_data) c_int; +pub extern fn seed48_r(__seed16v: [*c]c_ushort, __buffer: [*c]struct_drand48_data) c_int; +pub extern fn lcong48_r(__param: [*c]c_ushort, __buffer: [*c]struct_drand48_data) c_int; +pub extern fn arc4random() __uint32_t; +pub extern fn arc4random_buf(__buf: ?*anyopaque, __size: usize) void; +pub extern fn arc4random_uniform(__upper_bound: __uint32_t) __uint32_t; +pub extern fn malloc(__size: c_ulong) ?*anyopaque; +pub extern fn calloc(__nmemb: c_ulong, __size: c_ulong) ?*anyopaque; +pub extern fn realloc(__ptr: ?*anyopaque, __size: c_ulong) ?*anyopaque; +pub extern fn free(__ptr: ?*anyopaque) void; +pub extern fn reallocarray(__ptr: ?*anyopaque, __nmemb: usize, __size: usize) ?*anyopaque; +pub extern fn alloca(__size: c_ulong) ?*anyopaque; +pub extern fn valloc(__size: usize) ?*anyopaque; +pub extern fn posix_memalign(__memptr: [*c]?*anyopaque, __alignment: usize, __size: usize) c_int; +pub extern fn aligned_alloc(__alignment: c_ulong, __size: c_ulong) ?*anyopaque; +pub extern fn abort() noreturn; +pub extern fn atexit(__func: ?*const fn () callconv(.C) void) c_int; +pub extern fn at_quick_exit(__func: ?*const fn () callconv(.C) void) c_int; +pub extern fn on_exit(__func: ?*const fn (c_int, ?*anyopaque) callconv(.C) void, __arg: ?*anyopaque) c_int; +pub extern fn exit(__status: c_int) noreturn; +pub extern fn quick_exit(__status: c_int) noreturn; +pub extern fn _Exit(__status: c_int) noreturn; +pub extern fn getenv(__name: [*c]const u8) [*c]u8; +pub extern fn putenv(__string: [*c]u8) c_int; +pub extern fn setenv(__name: [*c]const u8, __value: [*c]const u8, __replace: c_int) c_int; +pub extern fn unsetenv(__name: [*c]const u8) c_int; +pub extern fn clearenv() c_int; +pub extern fn mktemp(__template: [*c]u8) [*c]u8; +pub extern fn mkstemp(__template: [*c]u8) c_int; +pub extern fn mkstemps(__template: [*c]u8, __suffixlen: c_int) c_int; +pub extern fn mkdtemp(__template: [*c]u8) [*c]u8; +pub extern fn system(__command: [*c]const u8) c_int; +pub extern fn realpath(noalias __name: [*c]const u8, noalias __resolved: [*c]u8) [*c]u8; +pub const __compar_fn_t = ?*const fn (?*const anyopaque, ?*const anyopaque) callconv(.C) c_int; +pub extern fn bsearch(__key: ?*const anyopaque, __base: ?*const anyopaque, __nmemb: usize, __size: usize, __compar: __compar_fn_t) ?*anyopaque; +pub extern fn qsort(__base: ?*anyopaque, __nmemb: usize, __size: usize, __compar: __compar_fn_t) void; +pub extern fn abs(__x: c_int) c_int; +pub extern fn labs(__x: c_long) c_long; +pub extern fn llabs(__x: c_longlong) c_longlong; +pub extern fn div(__numer: c_int, __denom: c_int) div_t; +pub extern fn ldiv(__numer: c_long, __denom: c_long) ldiv_t; +pub extern fn lldiv(__numer: c_longlong, __denom: c_longlong) lldiv_t; +pub extern fn ecvt(__value: f64, __ndigit: c_int, noalias __decpt: [*c]c_int, noalias __sign: [*c]c_int) [*c]u8; +pub extern fn fcvt(__value: f64, __ndigit: c_int, noalias __decpt: [*c]c_int, noalias __sign: [*c]c_int) [*c]u8; +pub extern fn gcvt(__value: f64, __ndigit: c_int, __buf: [*c]u8) [*c]u8; +pub extern fn qecvt(__value: c_longdouble, __ndigit: c_int, noalias __decpt: [*c]c_int, noalias __sign: [*c]c_int) [*c]u8; +pub extern fn qfcvt(__value: c_longdouble, __ndigit: c_int, noalias __decpt: [*c]c_int, noalias __sign: [*c]c_int) [*c]u8; +pub extern fn qgcvt(__value: c_longdouble, __ndigit: c_int, __buf: [*c]u8) [*c]u8; +pub extern fn ecvt_r(__value: f64, __ndigit: c_int, noalias __decpt: [*c]c_int, noalias __sign: [*c]c_int, noalias __buf: [*c]u8, __len: usize) c_int; +pub extern fn fcvt_r(__value: f64, __ndigit: c_int, noalias __decpt: [*c]c_int, noalias __sign: [*c]c_int, noalias __buf: [*c]u8, __len: usize) c_int; +pub extern fn qecvt_r(__value: c_longdouble, __ndigit: c_int, noalias __decpt: [*c]c_int, noalias __sign: [*c]c_int, noalias __buf: [*c]u8, __len: usize) c_int; +pub extern fn qfcvt_r(__value: c_longdouble, __ndigit: c_int, noalias __decpt: [*c]c_int, noalias __sign: [*c]c_int, noalias __buf: [*c]u8, __len: usize) c_int; +pub extern fn mblen(__s: [*c]const u8, __n: usize) c_int; +pub extern fn mbtowc(noalias __pwc: [*c]wchar_t, noalias __s: [*c]const u8, __n: usize) c_int; +pub extern fn wctomb(__s: [*c]u8, __wchar: wchar_t) c_int; +pub extern fn mbstowcs(noalias __pwcs: [*c]wchar_t, noalias __s: [*c]const u8, __n: usize) usize; +pub extern fn wcstombs(noalias __s: [*c]u8, noalias __pwcs: [*c]const wchar_t, __n: usize) usize; +pub extern fn rpmatch(__response: [*c]const u8) c_int; +pub extern fn getsubopt(noalias __optionp: [*c][*c]u8, noalias __tokens: [*c]const [*c]u8, noalias __valuep: [*c][*c]u8) c_int; +pub extern fn getloadavg(__loadavg: [*c]f64, __nelem: c_int) c_int; +pub const ptrdiff_t = c_long; +pub const max_align_t = extern struct { + __clang_max_align_nonce1: c_longlong align(8), + __clang_max_align_nonce2: c_longdouble align(16), +}; +pub const struct_tm = extern struct { + tm_sec: c_int, + tm_min: c_int, + tm_hour: c_int, + tm_mday: c_int, + tm_mon: c_int, + tm_year: c_int, + tm_wday: c_int, + tm_yday: c_int, + tm_isdst: c_int, + tm_gmtoff: c_long, + tm_zone: [*c]const u8, +}; +pub const struct_itimerspec = extern struct { + it_interval: struct_timespec, + it_value: struct_timespec, +}; +pub const union_sigval = extern union { + sival_int: c_int, + sival_ptr: ?*anyopaque, +}; +pub const __sigval_t = union_sigval; +const struct_unnamed_3 = extern struct { + _function: ?*const fn (__sigval_t) callconv(.C) void, + _attribute: [*c]pthread_attr_t, +}; +const union_unnamed_2 = extern union { + _pad: [12]c_int, + _tid: __pid_t, + _sigev_thread: struct_unnamed_3, +}; +pub const struct_sigevent = extern struct { + sigev_value: __sigval_t, + sigev_signo: c_int, + sigev_notify: c_int, + _sigev_un: union_unnamed_2, +}; +pub extern fn clock() clock_t; +pub extern fn time(__timer: [*c]time_t) time_t; +pub extern fn difftime(__time1: time_t, __time0: time_t) f64; +pub extern fn mktime(__tp: [*c]struct_tm) time_t; +pub extern fn strftime(noalias __s: [*c]u8, __maxsize: usize, noalias __format: [*c]const u8, noalias __tp: [*c]const struct_tm) usize; +pub extern fn strftime_l(noalias __s: [*c]u8, __maxsize: usize, noalias __format: [*c]const u8, noalias __tp: [*c]const struct_tm, __loc: locale_t) usize; +pub extern fn gmtime(__timer: [*c]const time_t) [*c]struct_tm; +pub extern fn localtime(__timer: [*c]const time_t) [*c]struct_tm; +pub extern fn gmtime_r(noalias __timer: [*c]const time_t, noalias __tp: [*c]struct_tm) [*c]struct_tm; +pub extern fn localtime_r(noalias __timer: [*c]const time_t, noalias __tp: [*c]struct_tm) [*c]struct_tm; +pub extern fn asctime(__tp: [*c]const struct_tm) [*c]u8; +pub extern fn ctime(__timer: [*c]const time_t) [*c]u8; +pub extern fn asctime_r(noalias __tp: [*c]const struct_tm, noalias __buf: [*c]u8) [*c]u8; +pub extern fn ctime_r(noalias __timer: [*c]const time_t, noalias __buf: [*c]u8) [*c]u8; +pub extern var __tzname: [2][*c]u8; +pub extern var __daylight: c_int; +pub extern var __timezone: c_long; +pub extern var tzname: [2][*c]u8; +pub extern fn tzset() void; +pub extern var daylight: c_int; +pub extern var timezone: c_long; +pub extern fn timegm(__tp: [*c]struct_tm) time_t; +pub extern fn timelocal(__tp: [*c]struct_tm) time_t; +pub extern fn dysize(__year: c_int) c_int; +pub extern fn nanosleep(__requested_time: [*c]const struct_timespec, __remaining: [*c]struct_timespec) c_int; +pub extern fn clock_getres(__clock_id: clockid_t, __res: [*c]struct_timespec) c_int; +pub extern fn clock_gettime(__clock_id: clockid_t, __tp: [*c]struct_timespec) c_int; +pub extern fn clock_settime(__clock_id: clockid_t, __tp: [*c]const struct_timespec) c_int; +pub extern fn clock_nanosleep(__clock_id: clockid_t, __flags: c_int, __req: [*c]const struct_timespec, __rem: [*c]struct_timespec) c_int; +pub extern fn clock_getcpuclockid(__pid: pid_t, __clock_id: [*c]clockid_t) c_int; +pub extern fn timer_create(__clock_id: clockid_t, noalias __evp: [*c]struct_sigevent, noalias __timerid: [*c]timer_t) c_int; +pub extern fn timer_delete(__timerid: timer_t) c_int; +pub extern fn timer_settime(__timerid: timer_t, __flags: c_int, noalias __value: [*c]const struct_itimerspec, noalias __ovalue: [*c]struct_itimerspec) c_int; +pub extern fn timer_gettime(__timerid: timer_t, __value: [*c]struct_itimerspec) c_int; +pub extern fn timer_getoverrun(__timerid: timer_t) c_int; +pub extern fn timespec_get(__ts: [*c]struct_timespec, __base: c_int) c_int; +pub const MemMalloc = ?*const fn (usize) callconv(.C) ?*anyopaque; +pub const MemFree = ?*const fn (?*anyopaque) callconv(.C) void; +pub const MemCalloc = ?*const fn (usize, usize) callconv(.C) ?*anyopaque; +pub const MemRealloc = ?*const fn (?*anyopaque, usize) callconv(.C) ?*anyopaque; +pub extern var arena_alloc_count: usize; +pub const struct_consumed_blk = extern struct { + prev: [*c]struct_consumed_blk, +}; +pub const ArenaMem = [*c]struct_consumed_blk; +pub const Arena = extern struct { + cur_blk: [*c]u8, + pos: usize, + size: usize, +}; +pub extern fn try_to_free_memory() void; +pub extern fn try_malloc(size: usize) ?*anyopaque; +pub extern fn verbose_try_malloc(size: usize) ?*anyopaque; +pub extern fn xmalloc(size: usize) ?*anyopaque; +pub extern fn xfree(ptr: ?*anyopaque) void; +pub extern fn xcalloc(count: usize, size: usize) ?*anyopaque; +pub extern fn xrealloc(ptr: ?*anyopaque, size: usize) ?*anyopaque; +pub extern fn xmallocz(size: usize) ?*anyopaque; +pub extern fn xmemdupz(data: ?*const anyopaque, len: usize) ?*anyopaque; +pub extern fn xstrchrnul(str: [*c]const u8, c: u8) [*c]u8; +pub extern fn xmemscan(addr: ?*const anyopaque, c: u8, size: usize) ?*anyopaque; +pub extern fn strchrsub(str: [*c]u8, c: u8, x: u8) void; +pub extern fn memchrsub(data: ?*anyopaque, c: u8, x: u8, len: usize) void; +pub extern fn strcnt(str: [*c]const u8, c: u8) usize; +pub extern fn memcnt(data: ?*const anyopaque, c: u8, len: usize) usize; +pub extern fn xstpcpy(noalias dst: [*c]u8, noalias src: [*c]const u8) [*c]u8; +pub extern fn xstpncpy(noalias dst: [*c]u8, noalias src: [*c]const u8, maxlen: usize) [*c]u8; +pub extern fn xstrlcpy(noalias dst: [*c]u8, noalias src: [*c]const u8, dsize: usize) usize; +pub extern fn xstrlcat(dst: [*c]u8, src: [*c]const u8, dsize: usize) usize; +pub extern fn xstrdup(str: [*c]const u8) [*c]u8; +pub extern fn xstrdupnul(str: [*c]const u8) [*c]u8; +pub extern fn xmemrchr(src: ?*const anyopaque, c: u8, len: usize) ?*anyopaque; +pub extern fn xstrndup(str: [*c]const u8, len: usize) [*c]u8; +pub extern fn xmemdup(data: ?*const anyopaque, len: usize) ?*anyopaque; +pub extern fn strequal(a: [*c]const u8, b: [*c]const u8) bool; +pub extern fn striequal(a: [*c]const u8, b: [*c]const u8) bool; +pub extern fn do_outofmem_msg(size: usize) void; +pub extern fn time_to_bytes(time_: time_t, buf: [*c]u8) void; +pub extern fn arena_finish(arena: [*c]Arena) ArenaMem; +pub extern fn alloc_block(arena: [*c]Arena) void; +pub extern fn arena_alloc(arena: [*c]Arena, size: usize, @"align": bool) ?*anyopaque; +pub extern fn arena_mem_free(mem: ArenaMem) void; +pub extern fn arena_memdupz(arena: [*c]Arena, buf: [*c]const u8, size: usize) [*c]u8; +pub const _ISupper: c_int = 256; +pub const _ISlower: c_int = 512; +pub const _ISalpha: c_int = 1024; +pub const _ISdigit: c_int = 2048; +pub const _ISxdigit: c_int = 4096; +pub const _ISspace: c_int = 8192; +pub const _ISprint: c_int = 16384; +pub const _ISgraph: c_int = 32768; +pub const _ISblank: c_int = 1; +pub const _IScntrl: c_int = 2; +pub const _ISpunct: c_int = 4; +pub const _ISalnum: c_int = 8; +const enum_unnamed_4 = c_uint; +pub extern fn __ctype_b_loc() [*c][*c]const c_ushort; +pub extern fn __ctype_tolower_loc() [*c][*c]const __int32_t; +pub extern fn __ctype_toupper_loc() [*c][*c]const __int32_t; +pub extern fn isalnum(c_int) c_int; +pub extern fn isalpha(c_int) c_int; +pub extern fn iscntrl(c_int) c_int; +pub extern fn isdigit(c_int) c_int; +pub extern fn islower(c_int) c_int; +pub extern fn isgraph(c_int) c_int; +pub extern fn isprint(c_int) c_int; +pub extern fn ispunct(c_int) c_int; +pub extern fn isspace(c_int) c_int; +pub extern fn isupper(c_int) c_int; +pub extern fn isxdigit(c_int) c_int; +pub extern fn tolower(__c: c_int) c_int; +pub extern fn toupper(__c: c_int) c_int; +pub extern fn isblank(c_int) c_int; +pub extern fn isascii(__c: c_int) c_int; +pub extern fn toascii(__c: c_int) c_int; +pub extern fn _toupper(c_int) c_int; +pub extern fn _tolower(c_int) c_int; +pub extern fn isalnum_l(c_int, locale_t) c_int; +pub extern fn isalpha_l(c_int, locale_t) c_int; +pub extern fn iscntrl_l(c_int, locale_t) c_int; +pub extern fn isdigit_l(c_int, locale_t) c_int; +pub extern fn islower_l(c_int, locale_t) c_int; +pub extern fn isgraph_l(c_int, locale_t) c_int; +pub extern fn isprint_l(c_int, locale_t) c_int; +pub extern fn ispunct_l(c_int, locale_t) c_int; +pub extern fn isspace_l(c_int, locale_t) c_int; +pub extern fn isupper_l(c_int, locale_t) c_int; +pub extern fn isxdigit_l(c_int, locale_t) c_int; +pub extern fn isblank_l(c_int, locale_t) c_int; +pub extern fn __tolower_l(__c: c_int, __l: locale_t) c_int; +pub extern fn tolower_l(__c: c_int, __l: locale_t) c_int; +pub extern fn __toupper_l(__c: c_int, __l: locale_t) c_int; +pub extern fn toupper_l(__c: c_int, __l: locale_t) c_int; +pub const struct___va_list_tag = extern struct { + gp_offset: c_uint, + fp_offset: c_uint, + overflow_arg_area: ?*anyopaque, + reg_save_area: ?*anyopaque, +}; +pub const __builtin_va_list = [1]struct___va_list_tag; +pub const __gnuc_va_list = __builtin_va_list; +const union_unnamed_5 = extern union { + __wch: c_uint, + __wchb: [4]u8, +}; +pub const __mbstate_t = extern struct { + __count: c_int, + __value: union_unnamed_5, +}; +pub const struct__G_fpos_t = extern struct { + __pos: __off_t, + __state: __mbstate_t, +}; +pub const __fpos_t = struct__G_fpos_t; +pub const struct__G_fpos64_t = extern struct { + __pos: __off64_t, + __state: __mbstate_t, +}; +pub const __fpos64_t = struct__G_fpos64_t; +pub const struct__IO_marker = opaque {}; +pub const _IO_lock_t = anyopaque; +pub const struct__IO_codecvt = opaque {}; +pub const struct__IO_wide_data = opaque {}; +pub const struct__IO_FILE = extern struct { + _flags: c_int, + _IO_read_ptr: [*c]u8, + _IO_read_end: [*c]u8, + _IO_read_base: [*c]u8, + _IO_write_base: [*c]u8, + _IO_write_ptr: [*c]u8, + _IO_write_end: [*c]u8, + _IO_buf_base: [*c]u8, + _IO_buf_end: [*c]u8, + _IO_save_base: [*c]u8, + _IO_backup_base: [*c]u8, + _IO_save_end: [*c]u8, + _markers: ?*struct__IO_marker, + _chain: [*c]struct__IO_FILE, + _fileno: c_int, + _flags2: c_int, + _old_offset: __off_t, + _cur_column: c_ushort, + _vtable_offset: i8, + _shortbuf: [1]u8, + _lock: ?*_IO_lock_t, + _offset: __off64_t, + _codecvt: ?*struct__IO_codecvt, + _wide_data: ?*struct__IO_wide_data, + _freeres_list: [*c]struct__IO_FILE, + _freeres_buf: ?*anyopaque, + __pad5: usize, + _mode: c_int, + _unused2: [20]u8, +}; +pub const __FILE = struct__IO_FILE; +pub const FILE = struct__IO_FILE; +pub const va_list = __gnuc_va_list; +pub const fpos_t = __fpos_t; +pub extern var stdin: [*c]FILE; +pub extern var stdout: [*c]FILE; +pub extern var stderr: [*c]FILE; +pub extern fn remove(__filename: [*c]const u8) c_int; +pub extern fn rename(__old: [*c]const u8, __new: [*c]const u8) c_int; +pub extern fn renameat(__oldfd: c_int, __old: [*c]const u8, __newfd: c_int, __new: [*c]const u8) c_int; +pub extern fn fclose(__stream: [*c]FILE) c_int; +pub extern fn tmpfile() [*c]FILE; +pub extern fn tmpnam([*c]u8) [*c]u8; +pub extern fn tmpnam_r(__s: [*c]u8) [*c]u8; +pub extern fn tempnam(__dir: [*c]const u8, __pfx: [*c]const u8) [*c]u8; +pub extern fn fflush(__stream: [*c]FILE) c_int; +pub extern fn fflush_unlocked(__stream: [*c]FILE) c_int; +pub extern fn fopen(__filename: [*c]const u8, __modes: [*c]const u8) [*c]FILE; +pub extern fn freopen(noalias __filename: [*c]const u8, noalias __modes: [*c]const u8, noalias __stream: [*c]FILE) [*c]FILE; +pub extern fn fdopen(__fd: c_int, __modes: [*c]const u8) [*c]FILE; +pub extern fn fmemopen(__s: ?*anyopaque, __len: usize, __modes: [*c]const u8) [*c]FILE; +pub extern fn open_memstream(__bufloc: [*c][*c]u8, __sizeloc: [*c]usize) [*c]FILE; +pub extern fn setbuf(noalias __stream: [*c]FILE, noalias __buf: [*c]u8) void; +pub extern fn setvbuf(noalias __stream: [*c]FILE, noalias __buf: [*c]u8, __modes: c_int, __n: usize) c_int; +pub extern fn setbuffer(noalias __stream: [*c]FILE, noalias __buf: [*c]u8, __size: usize) void; +pub extern fn setlinebuf(__stream: [*c]FILE) void; +pub extern fn fprintf(__stream: [*c]FILE, __format: [*c]const u8, ...) c_int; +pub extern fn printf(__format: [*c]const u8, ...) c_int; +pub extern fn sprintf(__s: [*c]u8, __format: [*c]const u8, ...) c_int; +pub extern fn vfprintf(__s: [*c]FILE, __format: [*c]const u8, __arg: [*c]struct___va_list_tag) c_int; +pub extern fn vprintf(__format: [*c]const u8, __arg: [*c]struct___va_list_tag) c_int; +pub extern fn vsprintf(__s: [*c]u8, __format: [*c]const u8, __arg: [*c]struct___va_list_tag) c_int; +pub extern fn snprintf(__s: [*c]u8, __maxlen: c_ulong, __format: [*c]const u8, ...) c_int; +pub extern fn vsnprintf(__s: [*c]u8, __maxlen: c_ulong, __format: [*c]const u8, __arg: [*c]struct___va_list_tag) c_int; +pub extern fn vdprintf(__fd: c_int, noalias __fmt: [*c]const u8, __arg: [*c]struct___va_list_tag) c_int; +pub extern fn dprintf(__fd: c_int, noalias __fmt: [*c]const u8, ...) c_int; +pub extern fn fscanf(noalias __stream: [*c]FILE, noalias __format: [*c]const u8, ...) c_int; +pub extern fn scanf(noalias __format: [*c]const u8, ...) c_int; +pub extern fn sscanf(noalias __s: [*c]const u8, noalias __format: [*c]const u8, ...) c_int; +pub extern fn vfscanf(noalias __s: [*c]FILE, noalias __format: [*c]const u8, __arg: [*c]struct___va_list_tag) c_int; +pub extern fn vscanf(noalias __format: [*c]const u8, __arg: [*c]struct___va_list_tag) c_int; +pub extern fn vsscanf(noalias __s: [*c]const u8, noalias __format: [*c]const u8, __arg: [*c]struct___va_list_tag) c_int; +pub extern fn fgetc(__stream: [*c]FILE) c_int; +pub extern fn getc(__stream: [*c]FILE) c_int; +pub extern fn getchar() c_int; +pub extern fn getc_unlocked(__stream: [*c]FILE) c_int; +pub extern fn getchar_unlocked() c_int; +pub extern fn fgetc_unlocked(__stream: [*c]FILE) c_int; +pub extern fn fputc(__c: c_int, __stream: [*c]FILE) c_int; +pub extern fn putc(__c: c_int, __stream: [*c]FILE) c_int; +pub extern fn putchar(__c: c_int) c_int; +pub extern fn fputc_unlocked(__c: c_int, __stream: [*c]FILE) c_int; +pub extern fn putc_unlocked(__c: c_int, __stream: [*c]FILE) c_int; +pub extern fn putchar_unlocked(__c: c_int) c_int; +pub extern fn getw(__stream: [*c]FILE) c_int; +pub extern fn putw(__w: c_int, __stream: [*c]FILE) c_int; +pub extern fn fgets(noalias __s: [*c]u8, __n: c_int, noalias __stream: [*c]FILE) [*c]u8; +pub extern fn __getdelim(noalias __lineptr: [*c][*c]u8, noalias __n: [*c]usize, __delimiter: c_int, noalias __stream: [*c]FILE) __ssize_t; +pub extern fn getdelim(noalias __lineptr: [*c][*c]u8, noalias __n: [*c]usize, __delimiter: c_int, noalias __stream: [*c]FILE) __ssize_t; +pub extern fn getline(noalias __lineptr: [*c][*c]u8, noalias __n: [*c]usize, noalias __stream: [*c]FILE) __ssize_t; +pub extern fn fputs(noalias __s: [*c]const u8, noalias __stream: [*c]FILE) c_int; +pub extern fn puts(__s: [*c]const u8) c_int; +pub extern fn ungetc(__c: c_int, __stream: [*c]FILE) c_int; +pub extern fn fread(__ptr: ?*anyopaque, __size: c_ulong, __n: c_ulong, __stream: [*c]FILE) c_ulong; +pub extern fn fwrite(__ptr: ?*const anyopaque, __size: c_ulong, __n: c_ulong, __s: [*c]FILE) c_ulong; +pub extern fn fread_unlocked(noalias __ptr: ?*anyopaque, __size: usize, __n: usize, noalias __stream: [*c]FILE) usize; +pub extern fn fwrite_unlocked(noalias __ptr: ?*const anyopaque, __size: usize, __n: usize, noalias __stream: [*c]FILE) usize; +pub extern fn fseek(__stream: [*c]FILE, __off: c_long, __whence: c_int) c_int; +pub extern fn ftell(__stream: [*c]FILE) c_long; +pub extern fn rewind(__stream: [*c]FILE) void; +pub extern fn fseeko(__stream: [*c]FILE, __off: __off_t, __whence: c_int) c_int; +pub extern fn ftello(__stream: [*c]FILE) __off_t; +pub extern fn fgetpos(noalias __stream: [*c]FILE, noalias __pos: [*c]fpos_t) c_int; +pub extern fn fsetpos(__stream: [*c]FILE, __pos: [*c]const fpos_t) c_int; +pub extern fn clearerr(__stream: [*c]FILE) void; +pub extern fn feof(__stream: [*c]FILE) c_int; +pub extern fn ferror(__stream: [*c]FILE) c_int; +pub extern fn clearerr_unlocked(__stream: [*c]FILE) void; +pub extern fn feof_unlocked(__stream: [*c]FILE) c_int; +pub extern fn ferror_unlocked(__stream: [*c]FILE) c_int; +pub extern fn perror(__s: [*c]const u8) void; +pub extern fn fileno(__stream: [*c]FILE) c_int; +pub extern fn fileno_unlocked(__stream: [*c]FILE) c_int; +pub extern fn pclose(__stream: [*c]FILE) c_int; +pub extern fn popen(__command: [*c]const u8, __modes: [*c]const u8) [*c]FILE; +pub extern fn ctermid(__s: [*c]u8) [*c]u8; +pub extern fn flockfile(__stream: [*c]FILE) void; +pub extern fn ftrylockfile(__stream: [*c]FILE) c_int; +pub extern fn funlockfile(__stream: [*c]FILE) void; +pub extern fn __uflow([*c]FILE) c_int; +pub extern fn __overflow([*c]FILE, c_int) c_int; +pub const struct_stat = extern struct { + st_dev: __dev_t, + st_ino: __ino_t, + st_nlink: __nlink_t, + st_mode: __mode_t, + st_uid: __uid_t, + st_gid: __gid_t, + __pad0: c_int, + st_rdev: __dev_t, + st_size: __off_t, + st_blksize: __blksize_t, + st_blocks: __blkcnt_t, + st_atim: struct_timespec, + st_mtim: struct_timespec, + st_ctim: struct_timespec, + __glibc_reserved: [3]__syscall_slong_t, +}; +pub extern fn stat(noalias __file: [*c]const u8, noalias __buf: [*c]struct_stat) c_int; +pub extern fn fstat(__fd: c_int, __buf: [*c]struct_stat) c_int; +pub extern fn fstatat(__fd: c_int, noalias __file: [*c]const u8, noalias __buf: [*c]struct_stat, __flag: c_int) c_int; +pub extern fn lstat(noalias __file: [*c]const u8, noalias __buf: [*c]struct_stat) c_int; +pub extern fn chmod(__file: [*c]const u8, __mode: __mode_t) c_int; +pub extern fn lchmod(__file: [*c]const u8, __mode: __mode_t) c_int; +pub extern fn fchmod(__fd: c_int, __mode: __mode_t) c_int; +pub extern fn fchmodat(__fd: c_int, __file: [*c]const u8, __mode: __mode_t, __flag: c_int) c_int; +pub extern fn umask(__mask: __mode_t) __mode_t; +pub extern fn mkdir(__path: [*c]const u8, __mode: __mode_t) c_int; +pub extern fn mkdirat(__fd: c_int, __path: [*c]const u8, __mode: __mode_t) c_int; +pub extern fn mknod(__path: [*c]const u8, __mode: __mode_t, __dev: __dev_t) c_int; +pub extern fn mknodat(__fd: c_int, __path: [*c]const u8, __mode: __mode_t, __dev: __dev_t) c_int; +pub extern fn mkfifo(__path: [*c]const u8, __mode: __mode_t) c_int; +pub extern fn mkfifoat(__fd: c_int, __path: [*c]const u8, __mode: __mode_t) c_int; +pub extern fn utimensat(__fd: c_int, __path: [*c]const u8, __times: [*c]const struct_timespec, __flags: c_int) c_int; +pub extern fn futimens(__fd: c_int, __times: [*c]const struct_timespec) c_int; +pub const sig_atomic_t = __sig_atomic_t; +const struct_unnamed_7 = extern struct { + si_pid: __pid_t, + si_uid: __uid_t, +}; +const struct_unnamed_8 = extern struct { + si_tid: c_int, + si_overrun: c_int, + si_sigval: __sigval_t, +}; +const struct_unnamed_9 = extern struct { + si_pid: __pid_t, + si_uid: __uid_t, + si_sigval: __sigval_t, +}; +const struct_unnamed_10 = extern struct { + si_pid: __pid_t, + si_uid: __uid_t, + si_status: c_int, + si_utime: __clock_t, + si_stime: __clock_t, +}; +const struct_unnamed_13 = extern struct { + _lower: ?*anyopaque, + _upper: ?*anyopaque, +}; +const union_unnamed_12 = extern union { + _addr_bnd: struct_unnamed_13, + _pkey: __uint32_t, +}; +const struct_unnamed_11 = extern struct { + si_addr: ?*anyopaque, + si_addr_lsb: c_short, + _bounds: union_unnamed_12, +}; +const struct_unnamed_14 = extern struct { + si_band: c_long, + si_fd: c_int, +}; +const struct_unnamed_15 = extern struct { + _call_addr: ?*anyopaque, + _syscall: c_int, + _arch: c_uint, +}; +const union_unnamed_6 = extern union { + _pad: [28]c_int, + _kill: struct_unnamed_7, + _timer: struct_unnamed_8, + _rt: struct_unnamed_9, + _sigchld: struct_unnamed_10, + _sigfault: struct_unnamed_11, + _sigpoll: struct_unnamed_14, + _sigsys: struct_unnamed_15, +}; +pub const siginfo_t = extern struct { + si_signo: c_int, + si_errno: c_int, + si_code: c_int, + __pad0: c_int, + _sifields: union_unnamed_6, +}; +pub const SI_ASYNCNL: c_int = -60; +pub const SI_DETHREAD: c_int = -7; +pub const SI_TKILL: c_int = -6; +pub const SI_SIGIO: c_int = -5; +pub const SI_ASYNCIO: c_int = -4; +pub const SI_MESGQ: c_int = -3; +pub const SI_TIMER: c_int = -2; +pub const SI_QUEUE: c_int = -1; +pub const SI_USER: c_int = 0; +pub const SI_KERNEL: c_int = 128; +const enum_unnamed_16 = c_int; +pub const ILL_ILLOPC: c_int = 1; +pub const ILL_ILLOPN: c_int = 2; +pub const ILL_ILLADR: c_int = 3; +pub const ILL_ILLTRP: c_int = 4; +pub const ILL_PRVOPC: c_int = 5; +pub const ILL_PRVREG: c_int = 6; +pub const ILL_COPROC: c_int = 7; +pub const ILL_BADSTK: c_int = 8; +pub const ILL_BADIADDR: c_int = 9; +const enum_unnamed_17 = c_uint; +pub const FPE_INTDIV: c_int = 1; +pub const FPE_INTOVF: c_int = 2; +pub const FPE_FLTDIV: c_int = 3; +pub const FPE_FLTOVF: c_int = 4; +pub const FPE_FLTUND: c_int = 5; +pub const FPE_FLTRES: c_int = 6; +pub const FPE_FLTINV: c_int = 7; +pub const FPE_FLTSUB: c_int = 8; +pub const FPE_FLTUNK: c_int = 14; +pub const FPE_CONDTRAP: c_int = 15; +const enum_unnamed_18 = c_uint; +pub const SEGV_MAPERR: c_int = 1; +pub const SEGV_ACCERR: c_int = 2; +pub const SEGV_BNDERR: c_int = 3; +pub const SEGV_PKUERR: c_int = 4; +pub const SEGV_ACCADI: c_int = 5; +pub const SEGV_ADIDERR: c_int = 6; +pub const SEGV_ADIPERR: c_int = 7; +pub const SEGV_MTEAERR: c_int = 8; +pub const SEGV_MTESERR: c_int = 9; +const enum_unnamed_19 = c_uint; +pub const BUS_ADRALN: c_int = 1; +pub const BUS_ADRERR: c_int = 2; +pub const BUS_OBJERR: c_int = 3; +pub const BUS_MCEERR_AR: c_int = 4; +pub const BUS_MCEERR_AO: c_int = 5; +const enum_unnamed_20 = c_uint; +pub const CLD_EXITED: c_int = 1; +pub const CLD_KILLED: c_int = 2; +pub const CLD_DUMPED: c_int = 3; +pub const CLD_TRAPPED: c_int = 4; +pub const CLD_STOPPED: c_int = 5; +pub const CLD_CONTINUED: c_int = 6; +const enum_unnamed_21 = c_uint; +pub const POLL_IN: c_int = 1; +pub const POLL_OUT: c_int = 2; +pub const POLL_MSG: c_int = 3; +pub const POLL_ERR: c_int = 4; +pub const POLL_PRI: c_int = 5; +pub const POLL_HUP: c_int = 6; +const enum_unnamed_22 = c_uint; +pub const sigval_t = __sigval_t; +pub const sigevent_t = struct_sigevent; +pub const SIGEV_SIGNAL: c_int = 0; +pub const SIGEV_NONE: c_int = 1; +pub const SIGEV_THREAD: c_int = 2; +pub const SIGEV_THREAD_ID: c_int = 4; +const enum_unnamed_23 = c_uint; +pub const __sighandler_t = ?*const fn (c_int) callconv(.C) void; +pub extern fn __sysv_signal(__sig: c_int, __handler: __sighandler_t) __sighandler_t; +pub extern fn signal(__sig: c_int, __handler: __sighandler_t) __sighandler_t; +pub extern fn kill(__pid: __pid_t, __sig: c_int) c_int; +pub extern fn killpg(__pgrp: __pid_t, __sig: c_int) c_int; +pub extern fn raise(__sig: c_int) c_int; +pub extern fn ssignal(__sig: c_int, __handler: __sighandler_t) __sighandler_t; +pub extern fn gsignal(__sig: c_int) c_int; +pub extern fn psignal(__sig: c_int, __s: [*c]const u8) void; +pub extern fn psiginfo(__pinfo: [*c]const siginfo_t, __s: [*c]const u8) void; +pub extern fn sigblock(__mask: c_int) c_int; +pub extern fn sigsetmask(__mask: c_int) c_int; +pub extern fn siggetmask() c_int; +pub const sig_t = __sighandler_t; +pub extern fn sigemptyset(__set: [*c]sigset_t) c_int; +pub extern fn sigfillset(__set: [*c]sigset_t) c_int; +pub extern fn sigaddset(__set: [*c]sigset_t, __signo: c_int) c_int; +pub extern fn sigdelset(__set: [*c]sigset_t, __signo: c_int) c_int; +pub extern fn sigismember(__set: [*c]const sigset_t, __signo: c_int) c_int; +const union_unnamed_24 = extern union { + sa_handler: __sighandler_t, + sa_sigaction: ?*const fn (c_int, [*c]siginfo_t, ?*anyopaque) callconv(.C) void, +}; +pub const struct_sigaction = extern struct { + __sigaction_handler: union_unnamed_24, + sa_mask: __sigset_t, + sa_flags: c_int, + sa_restorer: ?*const fn () callconv(.C) void, +}; +pub extern fn sigprocmask(__how: c_int, noalias __set: [*c]const sigset_t, noalias __oset: [*c]sigset_t) c_int; +pub extern fn sigsuspend(__set: [*c]const sigset_t) c_int; +pub extern fn sigaction(__sig: c_int, noalias __act: [*c]const struct_sigaction, noalias __oact: [*c]struct_sigaction) c_int; +pub extern fn sigpending(__set: [*c]sigset_t) c_int; +pub extern fn sigwait(noalias __set: [*c]const sigset_t, noalias __sig: [*c]c_int) c_int; +pub extern fn sigwaitinfo(noalias __set: [*c]const sigset_t, noalias __info: [*c]siginfo_t) c_int; +pub extern fn sigtimedwait(noalias __set: [*c]const sigset_t, noalias __info: [*c]siginfo_t, noalias __timeout: [*c]const struct_timespec) c_int; +pub extern fn sigqueue(__pid: __pid_t, __sig: c_int, __val: union_sigval) c_int; +pub const struct__fpx_sw_bytes = extern struct { + magic1: __uint32_t, + extended_size: __uint32_t, + xstate_bv: __uint64_t, + xstate_size: __uint32_t, + __glibc_reserved1: [7]__uint32_t, +}; +pub const struct__fpreg = extern struct { + significand: [4]c_ushort, + exponent: c_ushort, +}; +pub const struct__fpxreg = extern struct { + significand: [4]c_ushort, + exponent: c_ushort, + __glibc_reserved1: [3]c_ushort, +}; +pub const struct__xmmreg = extern struct { + element: [4]__uint32_t, +}; +pub const struct__fpstate = extern struct { + cwd: __uint16_t, + swd: __uint16_t, + ftw: __uint16_t, + fop: __uint16_t, + rip: __uint64_t, + rdp: __uint64_t, + mxcsr: __uint32_t, + mxcr_mask: __uint32_t, + _st: [8]struct__fpxreg, + _xmm: [16]struct__xmmreg, + __glibc_reserved1: [24]__uint32_t, +}; +const union_unnamed_25 = extern union { + fpstate: [*c]struct__fpstate, + __fpstate_word: __uint64_t, +}; +pub const struct_sigcontext = extern struct { + r8: __uint64_t, + r9: __uint64_t, + r10: __uint64_t, + r11: __uint64_t, + r12: __uint64_t, + r13: __uint64_t, + r14: __uint64_t, + r15: __uint64_t, + rdi: __uint64_t, + rsi: __uint64_t, + rbp: __uint64_t, + rbx: __uint64_t, + rdx: __uint64_t, + rax: __uint64_t, + rcx: __uint64_t, + rsp: __uint64_t, + rip: __uint64_t, + eflags: __uint64_t, + cs: c_ushort, + gs: c_ushort, + fs: c_ushort, + __pad0: c_ushort, + err: __uint64_t, + trapno: __uint64_t, + oldmask: __uint64_t, + cr2: __uint64_t, + unnamed_0: union_unnamed_25, + __reserved1: [8]__uint64_t, +}; +pub const struct__xsave_hdr = extern struct { + xstate_bv: __uint64_t, + __glibc_reserved1: [2]__uint64_t, + __glibc_reserved2: [5]__uint64_t, +}; +pub const struct__ymmh_state = extern struct { + ymmh_space: [64]__uint32_t, +}; +pub const struct__xstate = extern struct { + fpstate: struct__fpstate, + xstate_hdr: struct__xsave_hdr, + ymmh: struct__ymmh_state, +}; +pub extern fn sigreturn(__scp: [*c]struct_sigcontext) c_int; +pub const stack_t = extern struct { + ss_sp: ?*anyopaque, + ss_flags: c_int, + ss_size: usize, +}; +pub const greg_t = c_longlong; +pub const gregset_t = [23]greg_t; +pub const struct__libc_fpxreg = extern struct { + significand: [4]c_ushort, + exponent: c_ushort, + __glibc_reserved1: [3]c_ushort, +}; +pub const struct__libc_xmmreg = extern struct { + element: [4]__uint32_t, +}; +pub const struct__libc_fpstate = extern struct { + cwd: __uint16_t, + swd: __uint16_t, + ftw: __uint16_t, + fop: __uint16_t, + rip: __uint64_t, + rdp: __uint64_t, + mxcsr: __uint32_t, + mxcr_mask: __uint32_t, + _st: [8]struct__libc_fpxreg, + _xmm: [16]struct__libc_xmmreg, + __glibc_reserved1: [24]__uint32_t, +}; +pub const fpregset_t = [*c]struct__libc_fpstate; +pub const mcontext_t = extern struct { + gregs: gregset_t, + fpregs: fpregset_t, + __reserved1: [8]c_ulonglong, +}; +pub const struct_ucontext_t = extern struct { + uc_flags: c_ulong, + uc_link: [*c]struct_ucontext_t, + uc_stack: stack_t, + uc_mcontext: mcontext_t, + uc_sigmask: sigset_t, + __fpregs_mem: struct__libc_fpstate, + __ssp: [4]c_ulonglong, +}; +pub const ucontext_t = struct_ucontext_t; +pub extern fn siginterrupt(__sig: c_int, __interrupt: c_int) c_int; +pub const SS_ONSTACK: c_int = 1; +pub const SS_DISABLE: c_int = 2; +const enum_unnamed_26 = c_uint; +pub extern fn sigaltstack(noalias __ss: [*c]const stack_t, noalias __oss: [*c]stack_t) c_int; +pub const struct_sigstack = extern struct { + ss_sp: ?*anyopaque, + ss_onstack: c_int, +}; +pub extern fn sigstack(__ss: [*c]struct_sigstack, __oss: [*c]struct_sigstack) c_int; +pub extern fn pthread_sigmask(__how: c_int, noalias __newmask: [*c]const __sigset_t, noalias __oldmask: [*c]__sigset_t) c_int; +pub extern fn pthread_kill(__threadid: pthread_t, __signo: c_int) c_int; +pub extern fn __libc_current_sigrtmin() c_int; +pub extern fn __libc_current_sigrtmax() c_int; +pub const useconds_t = __useconds_t; +pub const socklen_t = __socklen_t; +pub extern fn access(__name: [*c]const u8, __type: c_int) c_int; +pub extern fn faccessat(__fd: c_int, __file: [*c]const u8, __type: c_int, __flag: c_int) c_int; +pub extern fn lseek(__fd: c_int, __offset: __off_t, __whence: c_int) __off_t; +pub extern fn close(__fd: c_int) c_int; +pub extern fn closefrom(__lowfd: c_int) void; +pub extern fn read(__fd: c_int, __buf: ?*anyopaque, __nbytes: usize) isize; +pub extern fn write(__fd: c_int, __buf: ?*const anyopaque, __n: usize) isize; +pub extern fn pread(__fd: c_int, __buf: ?*anyopaque, __nbytes: usize, __offset: __off_t) isize; +pub extern fn pwrite(__fd: c_int, __buf: ?*const anyopaque, __n: usize, __offset: __off_t) isize; +pub extern fn pipe(__pipedes: [*c]c_int) c_int; +pub extern fn alarm(__seconds: c_uint) c_uint; +pub extern fn sleep(__seconds: c_uint) c_uint; +pub extern fn ualarm(__value: __useconds_t, __interval: __useconds_t) __useconds_t; +pub extern fn usleep(__useconds: __useconds_t) c_int; +pub extern fn pause() c_int; +pub extern fn chown(__file: [*c]const u8, __owner: __uid_t, __group: __gid_t) c_int; +pub extern fn fchown(__fd: c_int, __owner: __uid_t, __group: __gid_t) c_int; +pub extern fn lchown(__file: [*c]const u8, __owner: __uid_t, __group: __gid_t) c_int; +pub extern fn fchownat(__fd: c_int, __file: [*c]const u8, __owner: __uid_t, __group: __gid_t, __flag: c_int) c_int; +pub extern fn chdir(__path: [*c]const u8) c_int; +pub extern fn fchdir(__fd: c_int) c_int; +pub extern fn getcwd(__buf: [*c]u8, __size: usize) [*c]u8; +pub extern fn getwd(__buf: [*c]u8) [*c]u8; +pub extern fn dup(__fd: c_int) c_int; +pub extern fn dup2(__fd: c_int, __fd2: c_int) c_int; +pub extern var __environ: [*c][*c]u8; +pub extern fn execve(__path: [*c]const u8, __argv: [*c]const [*c]u8, __envp: [*c]const [*c]u8) c_int; +pub extern fn fexecve(__fd: c_int, __argv: [*c]const [*c]u8, __envp: [*c]const [*c]u8) c_int; +pub extern fn execv(__path: [*c]const u8, __argv: [*c]const [*c]u8) c_int; +pub extern fn execle(__path: [*c]const u8, __arg: [*c]const u8, ...) c_int; +pub extern fn execl(__path: [*c]const u8, __arg: [*c]const u8, ...) c_int; +pub extern fn execvp(__file: [*c]const u8, __argv: [*c]const [*c]u8) c_int; +pub extern fn execlp(__file: [*c]const u8, __arg: [*c]const u8, ...) c_int; +pub extern fn nice(__inc: c_int) c_int; +pub extern fn _exit(__status: c_int) noreturn; +pub const _PC_LINK_MAX: c_int = 0; +pub const _PC_MAX_CANON: c_int = 1; +pub const _PC_MAX_INPUT: c_int = 2; +pub const _PC_NAME_MAX: c_int = 3; +pub const _PC_PATH_MAX: c_int = 4; +pub const _PC_PIPE_BUF: c_int = 5; +pub const _PC_CHOWN_RESTRICTED: c_int = 6; +pub const _PC_NO_TRUNC: c_int = 7; +pub const _PC_VDISABLE: c_int = 8; +pub const _PC_SYNC_IO: c_int = 9; +pub const _PC_ASYNC_IO: c_int = 10; +pub const _PC_PRIO_IO: c_int = 11; +pub const _PC_SOCK_MAXBUF: c_int = 12; +pub const _PC_FILESIZEBITS: c_int = 13; +pub const _PC_REC_INCR_XFER_SIZE: c_int = 14; +pub const _PC_REC_MAX_XFER_SIZE: c_int = 15; +pub const _PC_REC_MIN_XFER_SIZE: c_int = 16; +pub const _PC_REC_XFER_ALIGN: c_int = 17; +pub const _PC_ALLOC_SIZE_MIN: c_int = 18; +pub const _PC_SYMLINK_MAX: c_int = 19; +pub const _PC_2_SYMLINKS: c_int = 20; +const enum_unnamed_27 = c_uint; +pub const _SC_ARG_MAX: c_int = 0; +pub const _SC_CHILD_MAX: c_int = 1; +pub const _SC_CLK_TCK: c_int = 2; +pub const _SC_NGROUPS_MAX: c_int = 3; +pub const _SC_OPEN_MAX: c_int = 4; +pub const _SC_STREAM_MAX: c_int = 5; +pub const _SC_TZNAME_MAX: c_int = 6; +pub const _SC_JOB_CONTROL: c_int = 7; +pub const _SC_SAVED_IDS: c_int = 8; +pub const _SC_REALTIME_SIGNALS: c_int = 9; +pub const _SC_PRIORITY_SCHEDULING: c_int = 10; +pub const _SC_TIMERS: c_int = 11; +pub const _SC_ASYNCHRONOUS_IO: c_int = 12; +pub const _SC_PRIORITIZED_IO: c_int = 13; +pub const _SC_SYNCHRONIZED_IO: c_int = 14; +pub const _SC_FSYNC: c_int = 15; +pub const _SC_MAPPED_FILES: c_int = 16; +pub const _SC_MEMLOCK: c_int = 17; +pub const _SC_MEMLOCK_RANGE: c_int = 18; +pub const _SC_MEMORY_PROTECTION: c_int = 19; +pub const _SC_MESSAGE_PASSING: c_int = 20; +pub const _SC_SEMAPHORES: c_int = 21; +pub const _SC_SHARED_MEMORY_OBJECTS: c_int = 22; +pub const _SC_AIO_LISTIO_MAX: c_int = 23; +pub const _SC_AIO_MAX: c_int = 24; +pub const _SC_AIO_PRIO_DELTA_MAX: c_int = 25; +pub const _SC_DELAYTIMER_MAX: c_int = 26; +pub const _SC_MQ_OPEN_MAX: c_int = 27; +pub const _SC_MQ_PRIO_MAX: c_int = 28; +pub const _SC_VERSION: c_int = 29; +pub const _SC_PAGESIZE: c_int = 30; +pub const _SC_RTSIG_MAX: c_int = 31; +pub const _SC_SEM_NSEMS_MAX: c_int = 32; +pub const _SC_SEM_VALUE_MAX: c_int = 33; +pub const _SC_SIGQUEUE_MAX: c_int = 34; +pub const _SC_TIMER_MAX: c_int = 35; +pub const _SC_BC_BASE_MAX: c_int = 36; +pub const _SC_BC_DIM_MAX: c_int = 37; +pub const _SC_BC_SCALE_MAX: c_int = 38; +pub const _SC_BC_STRING_MAX: c_int = 39; +pub const _SC_COLL_WEIGHTS_MAX: c_int = 40; +pub const _SC_EQUIV_CLASS_MAX: c_int = 41; +pub const _SC_EXPR_NEST_MAX: c_int = 42; +pub const _SC_LINE_MAX: c_int = 43; +pub const _SC_RE_DUP_MAX: c_int = 44; +pub const _SC_CHARCLASS_NAME_MAX: c_int = 45; +pub const _SC_2_VERSION: c_int = 46; +pub const _SC_2_C_BIND: c_int = 47; +pub const _SC_2_C_DEV: c_int = 48; +pub const _SC_2_FORT_DEV: c_int = 49; +pub const _SC_2_FORT_RUN: c_int = 50; +pub const _SC_2_SW_DEV: c_int = 51; +pub const _SC_2_LOCALEDEF: c_int = 52; +pub const _SC_PII: c_int = 53; +pub const _SC_PII_XTI: c_int = 54; +pub const _SC_PII_SOCKET: c_int = 55; +pub const _SC_PII_INTERNET: c_int = 56; +pub const _SC_PII_OSI: c_int = 57; +pub const _SC_POLL: c_int = 58; +pub const _SC_SELECT: c_int = 59; +pub const _SC_UIO_MAXIOV: c_int = 60; +pub const _SC_IOV_MAX: c_int = 60; +pub const _SC_PII_INTERNET_STREAM: c_int = 61; +pub const _SC_PII_INTERNET_DGRAM: c_int = 62; +pub const _SC_PII_OSI_COTS: c_int = 63; +pub const _SC_PII_OSI_CLTS: c_int = 64; +pub const _SC_PII_OSI_M: c_int = 65; +pub const _SC_T_IOV_MAX: c_int = 66; +pub const _SC_THREADS: c_int = 67; +pub const _SC_THREAD_SAFE_FUNCTIONS: c_int = 68; +pub const _SC_GETGR_R_SIZE_MAX: c_int = 69; +pub const _SC_GETPW_R_SIZE_MAX: c_int = 70; +pub const _SC_LOGIN_NAME_MAX: c_int = 71; +pub const _SC_TTY_NAME_MAX: c_int = 72; +pub const _SC_THREAD_DESTRUCTOR_ITERATIONS: c_int = 73; +pub const _SC_THREAD_KEYS_MAX: c_int = 74; +pub const _SC_THREAD_STACK_MIN: c_int = 75; +pub const _SC_THREAD_THREADS_MAX: c_int = 76; +pub const _SC_THREAD_ATTR_STACKADDR: c_int = 77; +pub const _SC_THREAD_ATTR_STACKSIZE: c_int = 78; +pub const _SC_THREAD_PRIORITY_SCHEDULING: c_int = 79; +pub const _SC_THREAD_PRIO_INHERIT: c_int = 80; +pub const _SC_THREAD_PRIO_PROTECT: c_int = 81; +pub const _SC_THREAD_PROCESS_SHARED: c_int = 82; +pub const _SC_NPROCESSORS_CONF: c_int = 83; +pub const _SC_NPROCESSORS_ONLN: c_int = 84; +pub const _SC_PHYS_PAGES: c_int = 85; +pub const _SC_AVPHYS_PAGES: c_int = 86; +pub const _SC_ATEXIT_MAX: c_int = 87; +pub const _SC_PASS_MAX: c_int = 88; +pub const _SC_XOPEN_VERSION: c_int = 89; +pub const _SC_XOPEN_XCU_VERSION: c_int = 90; +pub const _SC_XOPEN_UNIX: c_int = 91; +pub const _SC_XOPEN_CRYPT: c_int = 92; +pub const _SC_XOPEN_ENH_I18N: c_int = 93; +pub const _SC_XOPEN_SHM: c_int = 94; +pub const _SC_2_CHAR_TERM: c_int = 95; +pub const _SC_2_C_VERSION: c_int = 96; +pub const _SC_2_UPE: c_int = 97; +pub const _SC_XOPEN_XPG2: c_int = 98; +pub const _SC_XOPEN_XPG3: c_int = 99; +pub const _SC_XOPEN_XPG4: c_int = 100; +pub const _SC_CHAR_BIT: c_int = 101; +pub const _SC_CHAR_MAX: c_int = 102; +pub const _SC_CHAR_MIN: c_int = 103; +pub const _SC_INT_MAX: c_int = 104; +pub const _SC_INT_MIN: c_int = 105; +pub const _SC_LONG_BIT: c_int = 106; +pub const _SC_WORD_BIT: c_int = 107; +pub const _SC_MB_LEN_MAX: c_int = 108; +pub const _SC_NZERO: c_int = 109; +pub const _SC_SSIZE_MAX: c_int = 110; +pub const _SC_SCHAR_MAX: c_int = 111; +pub const _SC_SCHAR_MIN: c_int = 112; +pub const _SC_SHRT_MAX: c_int = 113; +pub const _SC_SHRT_MIN: c_int = 114; +pub const _SC_UCHAR_MAX: c_int = 115; +pub const _SC_UINT_MAX: c_int = 116; +pub const _SC_ULONG_MAX: c_int = 117; +pub const _SC_USHRT_MAX: c_int = 118; +pub const _SC_NL_ARGMAX: c_int = 119; +pub const _SC_NL_LANGMAX: c_int = 120; +pub const _SC_NL_MSGMAX: c_int = 121; +pub const _SC_NL_NMAX: c_int = 122; +pub const _SC_NL_SETMAX: c_int = 123; +pub const _SC_NL_TEXTMAX: c_int = 124; +pub const _SC_XBS5_ILP32_OFF32: c_int = 125; +pub const _SC_XBS5_ILP32_OFFBIG: c_int = 126; +pub const _SC_XBS5_LP64_OFF64: c_int = 127; +pub const _SC_XBS5_LPBIG_OFFBIG: c_int = 128; +pub const _SC_XOPEN_LEGACY: c_int = 129; +pub const _SC_XOPEN_REALTIME: c_int = 130; +pub const _SC_XOPEN_REALTIME_THREADS: c_int = 131; +pub const _SC_ADVISORY_INFO: c_int = 132; +pub const _SC_BARRIERS: c_int = 133; +pub const _SC_BASE: c_int = 134; +pub const _SC_C_LANG_SUPPORT: c_int = 135; +pub const _SC_C_LANG_SUPPORT_R: c_int = 136; +pub const _SC_CLOCK_SELECTION: c_int = 137; +pub const _SC_CPUTIME: c_int = 138; +pub const _SC_THREAD_CPUTIME: c_int = 139; +pub const _SC_DEVICE_IO: c_int = 140; +pub const _SC_DEVICE_SPECIFIC: c_int = 141; +pub const _SC_DEVICE_SPECIFIC_R: c_int = 142; +pub const _SC_FD_MGMT: c_int = 143; +pub const _SC_FIFO: c_int = 144; +pub const _SC_PIPE: c_int = 145; +pub const _SC_FILE_ATTRIBUTES: c_int = 146; +pub const _SC_FILE_LOCKING: c_int = 147; +pub const _SC_FILE_SYSTEM: c_int = 148; +pub const _SC_MONOTONIC_CLOCK: c_int = 149; +pub const _SC_MULTI_PROCESS: c_int = 150; +pub const _SC_SINGLE_PROCESS: c_int = 151; +pub const _SC_NETWORKING: c_int = 152; +pub const _SC_READER_WRITER_LOCKS: c_int = 153; +pub const _SC_SPIN_LOCKS: c_int = 154; +pub const _SC_REGEXP: c_int = 155; +pub const _SC_REGEX_VERSION: c_int = 156; +pub const _SC_SHELL: c_int = 157; +pub const _SC_SIGNALS: c_int = 158; +pub const _SC_SPAWN: c_int = 159; +pub const _SC_SPORADIC_SERVER: c_int = 160; +pub const _SC_THREAD_SPORADIC_SERVER: c_int = 161; +pub const _SC_SYSTEM_DATABASE: c_int = 162; +pub const _SC_SYSTEM_DATABASE_R: c_int = 163; +pub const _SC_TIMEOUTS: c_int = 164; +pub const _SC_TYPED_MEMORY_OBJECTS: c_int = 165; +pub const _SC_USER_GROUPS: c_int = 166; +pub const _SC_USER_GROUPS_R: c_int = 167; +pub const _SC_2_PBS: c_int = 168; +pub const _SC_2_PBS_ACCOUNTING: c_int = 169; +pub const _SC_2_PBS_LOCATE: c_int = 170; +pub const _SC_2_PBS_MESSAGE: c_int = 171; +pub const _SC_2_PBS_TRACK: c_int = 172; +pub const _SC_SYMLOOP_MAX: c_int = 173; +pub const _SC_STREAMS: c_int = 174; +pub const _SC_2_PBS_CHECKPOINT: c_int = 175; +pub const _SC_V6_ILP32_OFF32: c_int = 176; +pub const _SC_V6_ILP32_OFFBIG: c_int = 177; +pub const _SC_V6_LP64_OFF64: c_int = 178; +pub const _SC_V6_LPBIG_OFFBIG: c_int = 179; +pub const _SC_HOST_NAME_MAX: c_int = 180; +pub const _SC_TRACE: c_int = 181; +pub const _SC_TRACE_EVENT_FILTER: c_int = 182; +pub const _SC_TRACE_INHERIT: c_int = 183; +pub const _SC_TRACE_LOG: c_int = 184; +pub const _SC_LEVEL1_ICACHE_SIZE: c_int = 185; +pub const _SC_LEVEL1_ICACHE_ASSOC: c_int = 186; +pub const _SC_LEVEL1_ICACHE_LINESIZE: c_int = 187; +pub const _SC_LEVEL1_DCACHE_SIZE: c_int = 188; +pub const _SC_LEVEL1_DCACHE_ASSOC: c_int = 189; +pub const _SC_LEVEL1_DCACHE_LINESIZE: c_int = 190; +pub const _SC_LEVEL2_CACHE_SIZE: c_int = 191; +pub const _SC_LEVEL2_CACHE_ASSOC: c_int = 192; +pub const _SC_LEVEL2_CACHE_LINESIZE: c_int = 193; +pub const _SC_LEVEL3_CACHE_SIZE: c_int = 194; +pub const _SC_LEVEL3_CACHE_ASSOC: c_int = 195; +pub const _SC_LEVEL3_CACHE_LINESIZE: c_int = 196; +pub const _SC_LEVEL4_CACHE_SIZE: c_int = 197; +pub const _SC_LEVEL4_CACHE_ASSOC: c_int = 198; +pub const _SC_LEVEL4_CACHE_LINESIZE: c_int = 199; +pub const _SC_IPV6: c_int = 235; +pub const _SC_RAW_SOCKETS: c_int = 236; +pub const _SC_V7_ILP32_OFF32: c_int = 237; +pub const _SC_V7_ILP32_OFFBIG: c_int = 238; +pub const _SC_V7_LP64_OFF64: c_int = 239; +pub const _SC_V7_LPBIG_OFFBIG: c_int = 240; +pub const _SC_SS_REPL_MAX: c_int = 241; +pub const _SC_TRACE_EVENT_NAME_MAX: c_int = 242; +pub const _SC_TRACE_NAME_MAX: c_int = 243; +pub const _SC_TRACE_SYS_MAX: c_int = 244; +pub const _SC_TRACE_USER_EVENT_MAX: c_int = 245; +pub const _SC_XOPEN_STREAMS: c_int = 246; +pub const _SC_THREAD_ROBUST_PRIO_INHERIT: c_int = 247; +pub const _SC_THREAD_ROBUST_PRIO_PROTECT: c_int = 248; +pub const _SC_MINSIGSTKSZ: c_int = 249; +pub const _SC_SIGSTKSZ: c_int = 250; +const enum_unnamed_28 = c_uint; +pub const _CS_PATH: c_int = 0; +pub const _CS_V6_WIDTH_RESTRICTED_ENVS: c_int = 1; +pub const _CS_GNU_LIBC_VERSION: c_int = 2; +pub const _CS_GNU_LIBPTHREAD_VERSION: c_int = 3; +pub const _CS_V5_WIDTH_RESTRICTED_ENVS: c_int = 4; +pub const _CS_V7_WIDTH_RESTRICTED_ENVS: c_int = 5; +pub const _CS_LFS_CFLAGS: c_int = 1000; +pub const _CS_LFS_LDFLAGS: c_int = 1001; +pub const _CS_LFS_LIBS: c_int = 1002; +pub const _CS_LFS_LINTFLAGS: c_int = 1003; +pub const _CS_LFS64_CFLAGS: c_int = 1004; +pub const _CS_LFS64_LDFLAGS: c_int = 1005; +pub const _CS_LFS64_LIBS: c_int = 1006; +pub const _CS_LFS64_LINTFLAGS: c_int = 1007; +pub const _CS_XBS5_ILP32_OFF32_CFLAGS: c_int = 1100; +pub const _CS_XBS5_ILP32_OFF32_LDFLAGS: c_int = 1101; +pub const _CS_XBS5_ILP32_OFF32_LIBS: c_int = 1102; +pub const _CS_XBS5_ILP32_OFF32_LINTFLAGS: c_int = 1103; +pub const _CS_XBS5_ILP32_OFFBIG_CFLAGS: c_int = 1104; +pub const _CS_XBS5_ILP32_OFFBIG_LDFLAGS: c_int = 1105; +pub const _CS_XBS5_ILP32_OFFBIG_LIBS: c_int = 1106; +pub const _CS_XBS5_ILP32_OFFBIG_LINTFLAGS: c_int = 1107; +pub const _CS_XBS5_LP64_OFF64_CFLAGS: c_int = 1108; +pub const _CS_XBS5_LP64_OFF64_LDFLAGS: c_int = 1109; +pub const _CS_XBS5_LP64_OFF64_LIBS: c_int = 1110; +pub const _CS_XBS5_LP64_OFF64_LINTFLAGS: c_int = 1111; +pub const _CS_XBS5_LPBIG_OFFBIG_CFLAGS: c_int = 1112; +pub const _CS_XBS5_LPBIG_OFFBIG_LDFLAGS: c_int = 1113; +pub const _CS_XBS5_LPBIG_OFFBIG_LIBS: c_int = 1114; +pub const _CS_XBS5_LPBIG_OFFBIG_LINTFLAGS: c_int = 1115; +pub const _CS_POSIX_V6_ILP32_OFF32_CFLAGS: c_int = 1116; +pub const _CS_POSIX_V6_ILP32_OFF32_LDFLAGS: c_int = 1117; +pub const _CS_POSIX_V6_ILP32_OFF32_LIBS: c_int = 1118; +pub const _CS_POSIX_V6_ILP32_OFF32_LINTFLAGS: c_int = 1119; +pub const _CS_POSIX_V6_ILP32_OFFBIG_CFLAGS: c_int = 1120; +pub const _CS_POSIX_V6_ILP32_OFFBIG_LDFLAGS: c_int = 1121; +pub const _CS_POSIX_V6_ILP32_OFFBIG_LIBS: c_int = 1122; +pub const _CS_POSIX_V6_ILP32_OFFBIG_LINTFLAGS: c_int = 1123; +pub const _CS_POSIX_V6_LP64_OFF64_CFLAGS: c_int = 1124; +pub const _CS_POSIX_V6_LP64_OFF64_LDFLAGS: c_int = 1125; +pub const _CS_POSIX_V6_LP64_OFF64_LIBS: c_int = 1126; +pub const _CS_POSIX_V6_LP64_OFF64_LINTFLAGS: c_int = 1127; +pub const _CS_POSIX_V6_LPBIG_OFFBIG_CFLAGS: c_int = 1128; +pub const _CS_POSIX_V6_LPBIG_OFFBIG_LDFLAGS: c_int = 1129; +pub const _CS_POSIX_V6_LPBIG_OFFBIG_LIBS: c_int = 1130; +pub const _CS_POSIX_V6_LPBIG_OFFBIG_LINTFLAGS: c_int = 1131; +pub const _CS_POSIX_V7_ILP32_OFF32_CFLAGS: c_int = 1132; +pub const _CS_POSIX_V7_ILP32_OFF32_LDFLAGS: c_int = 1133; +pub const _CS_POSIX_V7_ILP32_OFF32_LIBS: c_int = 1134; +pub const _CS_POSIX_V7_ILP32_OFF32_LINTFLAGS: c_int = 1135; +pub const _CS_POSIX_V7_ILP32_OFFBIG_CFLAGS: c_int = 1136; +pub const _CS_POSIX_V7_ILP32_OFFBIG_LDFLAGS: c_int = 1137; +pub const _CS_POSIX_V7_ILP32_OFFBIG_LIBS: c_int = 1138; +pub const _CS_POSIX_V7_ILP32_OFFBIG_LINTFLAGS: c_int = 1139; +pub const _CS_POSIX_V7_LP64_OFF64_CFLAGS: c_int = 1140; +pub const _CS_POSIX_V7_LP64_OFF64_LDFLAGS: c_int = 1141; +pub const _CS_POSIX_V7_LP64_OFF64_LIBS: c_int = 1142; +pub const _CS_POSIX_V7_LP64_OFF64_LINTFLAGS: c_int = 1143; +pub const _CS_POSIX_V7_LPBIG_OFFBIG_CFLAGS: c_int = 1144; +pub const _CS_POSIX_V7_LPBIG_OFFBIG_LDFLAGS: c_int = 1145; +pub const _CS_POSIX_V7_LPBIG_OFFBIG_LIBS: c_int = 1146; +pub const _CS_POSIX_V7_LPBIG_OFFBIG_LINTFLAGS: c_int = 1147; +pub const _CS_V6_ENV: c_int = 1148; +pub const _CS_V7_ENV: c_int = 1149; +const enum_unnamed_29 = c_uint; +pub extern fn pathconf(__path: [*c]const u8, __name: c_int) c_long; +pub extern fn fpathconf(__fd: c_int, __name: c_int) c_long; +pub extern fn sysconf(__name: c_int) c_long; +pub extern fn confstr(__name: c_int, __buf: [*c]u8, __len: usize) usize; +pub extern fn getpid() __pid_t; +pub extern fn getppid() __pid_t; +pub extern fn getpgrp() __pid_t; +pub extern fn __getpgid(__pid: __pid_t) __pid_t; +pub extern fn getpgid(__pid: __pid_t) __pid_t; +pub extern fn setpgid(__pid: __pid_t, __pgid: __pid_t) c_int; +pub extern fn setpgrp() c_int; +pub extern fn setsid() __pid_t; +pub extern fn getsid(__pid: __pid_t) __pid_t; +pub extern fn getuid() __uid_t; +pub extern fn geteuid() __uid_t; +pub extern fn getgid() __gid_t; +pub extern fn getegid() __gid_t; +pub extern fn getgroups(__size: c_int, __list: [*c]__gid_t) c_int; +pub extern fn setuid(__uid: __uid_t) c_int; +pub extern fn setreuid(__ruid: __uid_t, __euid: __uid_t) c_int; +pub extern fn seteuid(__uid: __uid_t) c_int; +pub extern fn setgid(__gid: __gid_t) c_int; +pub extern fn setregid(__rgid: __gid_t, __egid: __gid_t) c_int; +pub extern fn setegid(__gid: __gid_t) c_int; +pub extern fn fork() __pid_t; +pub extern fn vfork() c_int; +pub extern fn ttyname(__fd: c_int) [*c]u8; +pub extern fn ttyname_r(__fd: c_int, __buf: [*c]u8, __buflen: usize) c_int; +pub extern fn isatty(__fd: c_int) c_int; +pub extern fn ttyslot() c_int; +pub extern fn link(__from: [*c]const u8, __to: [*c]const u8) c_int; +pub extern fn linkat(__fromfd: c_int, __from: [*c]const u8, __tofd: c_int, __to: [*c]const u8, __flags: c_int) c_int; +pub extern fn symlink(__from: [*c]const u8, __to: [*c]const u8) c_int; +pub extern fn readlink(noalias __path: [*c]const u8, noalias __buf: [*c]u8, __len: usize) isize; +pub extern fn symlinkat(__from: [*c]const u8, __tofd: c_int, __to: [*c]const u8) c_int; +pub extern fn readlinkat(__fd: c_int, noalias __path: [*c]const u8, noalias __buf: [*c]u8, __len: usize) isize; +pub extern fn unlink(__name: [*c]const u8) c_int; +pub extern fn unlinkat(__fd: c_int, __name: [*c]const u8, __flag: c_int) c_int; +pub extern fn rmdir(__path: [*c]const u8) c_int; +pub extern fn tcgetpgrp(__fd: c_int) __pid_t; +pub extern fn tcsetpgrp(__fd: c_int, __pgrp_id: __pid_t) c_int; +pub extern fn getlogin() [*c]u8; +pub extern fn getlogin_r(__name: [*c]u8, __name_len: usize) c_int; +pub extern fn setlogin(__name: [*c]const u8) c_int; +pub extern var optarg: [*c]u8; +pub extern var optind: c_int; +pub extern var opterr: c_int; +pub extern var optopt: c_int; +pub extern fn getopt(___argc: c_int, ___argv: [*c]const [*c]u8, __shortopts: [*c]const u8) c_int; +pub extern fn gethostname(__name: [*c]u8, __len: usize) c_int; +pub extern fn sethostname(__name: [*c]const u8, __len: usize) c_int; +pub extern fn sethostid(__id: c_long) c_int; +pub extern fn getdomainname(__name: [*c]u8, __len: usize) c_int; +pub extern fn setdomainname(__name: [*c]const u8, __len: usize) c_int; +pub extern fn vhangup() c_int; +pub extern fn revoke(__file: [*c]const u8) c_int; +pub extern fn profil(__sample_buffer: [*c]c_ushort, __size: usize, __offset: usize, __scale: c_uint) c_int; +pub extern fn acct(__name: [*c]const u8) c_int; +pub extern fn getusershell() [*c]u8; +pub extern fn endusershell() void; +pub extern fn setusershell() void; +pub extern fn daemon(__nochdir: c_int, __noclose: c_int) c_int; +pub extern fn chroot(__path: [*c]const u8) c_int; +pub extern fn getpass(__prompt: [*c]const u8) [*c]u8; +pub extern fn fsync(__fd: c_int) c_int; +pub extern fn gethostid() c_long; +pub extern fn sync() void; +pub extern fn getpagesize() c_int; +pub extern fn getdtablesize() c_int; +pub extern fn truncate(__file: [*c]const u8, __length: __off_t) c_int; +pub extern fn ftruncate(__fd: c_int, __length: __off_t) c_int; +pub extern fn brk(__addr: ?*anyopaque) c_int; +pub extern fn sbrk(__delta: isize) ?*anyopaque; +pub extern fn syscall(__sysno: c_long, ...) c_long; +pub extern fn lockf(__fd: c_int, __cmd: c_int, __len: __off_t) c_int; +pub extern fn fdatasync(__fildes: c_int) c_int; +pub extern fn crypt(__key: [*c]const u8, __salt: [*c]const u8) [*c]u8; +pub extern fn getentropy(__buffer: ?*anyopaque, __length: usize) c_int; +pub const cc_t = u8; +pub const speed_t = c_uint; +pub const tcflag_t = c_uint; +pub const struct_termios = extern struct { + c_iflag: tcflag_t, + c_oflag: tcflag_t, + c_cflag: tcflag_t, + c_lflag: tcflag_t, + c_line: cc_t, + c_cc: [32]cc_t, + c_ispeed: speed_t, + c_ospeed: speed_t, +}; +pub extern fn cfgetospeed(__termios_p: [*c]const struct_termios) speed_t; +pub extern fn cfgetispeed(__termios_p: [*c]const struct_termios) speed_t; +pub extern fn cfsetospeed(__termios_p: [*c]struct_termios, __speed: speed_t) c_int; +pub extern fn cfsetispeed(__termios_p: [*c]struct_termios, __speed: speed_t) c_int; +pub extern fn cfsetspeed(__termios_p: [*c]struct_termios, __speed: speed_t) c_int; +pub extern fn tcgetattr(__fd: c_int, __termios_p: [*c]struct_termios) c_int; +pub extern fn tcsetattr(__fd: c_int, __optional_actions: c_int, __termios_p: [*c]const struct_termios) c_int; +pub extern fn cfmakeraw(__termios_p: [*c]struct_termios) void; +pub extern fn tcsendbreak(__fd: c_int, __duration: c_int) c_int; +pub extern fn tcdrain(__fd: c_int) c_int; +pub extern fn tcflush(__fd: c_int, __queue_selector: c_int) c_int; +pub extern fn tcflow(__fd: c_int, __action: c_int) c_int; +pub extern fn tcgetsid(__fd: c_int) __pid_t; +pub fn _memcpy_free(noalias dest: ?*anyopaque, noalias src: ?*anyopaque, size: usize) callconv(.C) ?*anyopaque { + _ = memcpy(dest, src, size); + while (true) { + var ptr_: [*c]?*anyopaque = @intToPtr([*c]?*anyopaque, @ptrToInt(&src)); + xfree(ptr_.*); + ptr_.* = @intToPtr(?*anyopaque, @as(c_int, 0)); + _ = ptr_.*; + if (!false) break; + } + return dest; +} +pub const vim_acl_T = ?*anyopaque; +pub const u8char_T = u32; +pub const handle_T = c_int; +pub const LuaRef = c_int; +pub const float_T = f64; +pub const Boolean = bool; +pub const Integer = i64; +pub const Float = f64; +const union_unnamed_30 = extern union { + boolean: Boolean, + integer: Integer, + floating: Float, + string: String, + array: Array, + dictionary: Dictionary, + luaref: LuaRef, +}; +pub const struct_object = extern struct { + type: ObjectType, + data: union_unnamed_30, +}; +pub const Object = struct_object; +pub const ApiDispatchWrapper = ?*const fn (u64, Array, [*c]Arena, [*c]Error) callconv(.C) Object; +pub const struct_MsgpackRpcRequestHandler = extern struct { + name: [*c]const u8, + @"fn": ApiDispatchWrapper, + fast: bool, + arena_return: bool, +}; +pub const MsgpackRpcRequestHandler = struct_MsgpackRpcRequestHandler; +pub const EvalFuncData = extern union { + float_func: ?*const fn (float_T) callconv(.C) float_T, + api_handler: [*c]const MsgpackRpcRequestHandler, + null: ?*anyopaque, +}; +pub const NS = handle_T; +pub const struct_expand = extern struct { + xp_pattern: [*c]u8, + xp_context: c_int, + xp_pattern_len: usize, + xp_arg: [*c]u8, + xp_luaref: LuaRef, + xp_script_ctx: sctx_T, + xp_backslash: c_int, + xp_shell: c_int, + xp_numfiles: c_int, + xp_col: c_int, + xp_files: [*c][*c]u8, + xp_line: [*c]u8, + xp_buf: [256]u8, +}; +pub const expand_T = struct_expand; +pub const proftime_T = u64; +pub const kNone: c_int = -1; +pub const kFalse: c_int = 0; +pub const kTrue: c_int = 1; +pub const TriState = c_int; +pub const DecorPriority = u16; +pub const struct_Decoration = extern struct { + virt_text: VirtText, + virt_lines: VirtLines, + hl_id: c_int, + virt_text_pos: VirtTextPos, + hl_mode: HlMode, + virt_text_hide: bool, + hl_eol: bool, + virt_lines_above: bool, + conceal: bool, + spell: TriState, + priority: DecorPriority, + col: c_int, + virt_text_width: c_int, + sign_text: [*c]u8, + sign_hl_id: c_int, + number_hl_id: c_int, + line_hl_id: c_int, + cursorline_hl_id: c_int, + conceal_char: c_int, + ui_watched: bool, +}; +pub const Decoration = struct_Decoration; +pub const kErrorTypeNone: c_int = -1; +pub const kErrorTypeException: c_int = 0; +pub const kErrorTypeValidation: c_int = 1; +pub const ErrorType = c_int; +pub const kMessageTypeUnknown: c_int = -1; +pub const kMessageTypeRequest: c_int = 0; +pub const kMessageTypeResponse: c_int = 1; +pub const kMessageTypeNotification: c_int = 2; +pub const kMessageTypeRedrawEvent: c_int = 3; +pub const MessageType = c_int; +pub inline fn is_internal_call(channel_id: u64) bool { + return !!((channel_id & (@bitCast(u64, @as(c_long, @as(c_int, 1))) << @intCast(@import("std").math.Log2Int(u64), (@sizeOf(u64) *% @bitCast(c_ulong, @as(c_long, @as(c_int, 8)))) -% @bitCast(c_ulong, @as(c_long, @as(c_int, 1)))))) != 0); +} +pub const Error = extern struct { + type: ErrorType, + msg: [*c]u8, +}; +pub const String = extern struct { + data: [*c]u8, + size: usize, +}; +pub const Buffer = handle_T; +pub const Window = handle_T; +pub const Tabpage = handle_T; +pub const Array = extern struct { + size: usize, + capacity: usize, + items: [*c]Object, +}; +pub const struct_key_value_pair = extern struct { + key: String, + value: Object, +}; +pub const KeyValuePair = struct_key_value_pair; +pub const Dictionary = extern struct { + size: usize, + capacity: usize, + items: [*c]KeyValuePair, +}; +pub const kObjectTypeNil: c_int = 0; +pub const kObjectTypeBoolean: c_int = 1; +pub const kObjectTypeInteger: c_int = 2; +pub const kObjectTypeFloat: c_int = 3; +pub const kObjectTypeString: c_int = 4; +pub const kObjectTypeArray: c_int = 5; +pub const kObjectTypeDictionary: c_int = 6; +pub const kObjectTypeLuaRef: c_int = 7; +pub const kObjectTypeBuffer: c_int = 8; +pub const kObjectTypeWindow: c_int = 9; +pub const kObjectTypeTabpage: c_int = 10; +pub const ObjectType = c_uint; +pub const field_hash = ?*const fn (?*anyopaque, [*c]const u8, usize) callconv(.C) [*c]Object; +pub const KeySetLink = extern struct { + str: [*c]u8, + ptr_off: usize, +}; +pub const KeyDict_context = extern struct { + types: Object, +}; +pub const KeyDict_set_decoration_provider = extern struct { + on_start: Object, + on_buf: Object, + on_win: Object, + on_line: Object, + on_end: Object, + _on_hl_def: Object, + _on_spell_nav: Object, +}; +pub const KeyDict_set_extmark = extern struct { + id: Object, + end_line: Object, + end_row: Object, + end_col: Object, + hl_group: Object, + virt_text: Object, + virt_text_pos: Object, + virt_text_win_col: Object, + virt_text_hide: Object, + hl_eol: Object, + hl_mode: Object, + ephemeral: Object, + priority: Object, + right_gravity: Object, + end_right_gravity: Object, + virt_lines: Object, + virt_lines_above: Object, + virt_lines_leftcol: Object, + strict: Object, + sign_text: Object, + sign_hl_group: Object, + number_hl_group: Object, + line_hl_group: Object, + cursorline_hl_group: Object, + conceal: Object, + spell: Object, + ui_watched: Object, +}; +pub const KeyDict_keymap = extern struct { + noremap: Object, + nowait: Object, + silent: Object, + script: Object, + expr: Object, + unique: Object, + callback: Object, + desc: Object, + replace_keycodes: Object, +}; +pub const KeyDict_get_commands = extern struct { + builtin: Object, +}; +pub const KeyDict_user_command = extern struct { + addr: Object, + bang: Object, + bar: Object, + complete: Object, + count: Object, + desc: Object, + force: Object, + keepscript: Object, + nargs: Object, + preview: Object, + range: Object, + register_: Object, +}; +pub const KeyDict_float_config = extern struct { + row: Object, + col: Object, + width: Object, + height: Object, + anchor: Object, + relative: Object, + win: Object, + bufpos: Object, + external: Object, + focusable: Object, + zindex: Object, + border: Object, + title: Object, + title_pos: Object, + style: Object, + noautocmd: Object, +}; +pub const KeyDict_runtime = extern struct { + is_lua: Object, + do_source: Object, +}; +pub const KeyDict_eval_statusline = extern struct { + winid: Object, + maxwidth: Object, + fillchar: Object, + highlights: Object, + use_winbar: Object, + use_tabline: Object, + use_statuscol_lnum: Object, +}; +pub const KeyDict_option = extern struct { + scope: Object, + win: Object, + buf: Object, + filetype: Object, +}; +pub const KeyDict_highlight = extern struct { + bold: Object, + standout: Object, + strikethrough: Object, + underline: Object, + undercurl: Object, + underdouble: Object, + underdotted: Object, + underdashed: Object, + italic: Object, + reverse: Object, + altfont: Object, + nocombine: Object, + default_: Object, + cterm: Object, + foreground: Object, + fg: Object, + background: Object, + bg: Object, + ctermfg: Object, + ctermbg: Object, + special: Object, + sp: Object, + link: Object, + global_link: Object, + fallback: Object, + blend: Object, + fg_indexed: Object, + bg_indexed: Object, +}; +pub const KeyDict_highlight_cterm = extern struct { + bold: Object, + standout: Object, + strikethrough: Object, + underline: Object, + undercurl: Object, + underdouble: Object, + underdotted: Object, + underdashed: Object, + italic: Object, + reverse: Object, + altfont: Object, + nocombine: Object, +}; +pub const KeyDict_get_highlight = extern struct { + id: Object, + name: Object, + link: Object, +}; +pub const KeyDict_clear_autocmds = extern struct { + buffer: Object, + event: Object, + group: Object, + pattern: Object, +}; +pub const KeyDict_create_autocmd = extern struct { + buffer: Object, + callback: Object, + command: Object, + desc: Object, + group: Object, + nested: Object, + once: Object, + pattern: Object, +}; +pub const KeyDict_exec_autocmds = extern struct { + buffer: Object, + group: Object, + modeline: Object, + pattern: Object, + data: Object, +}; +pub const KeyDict_get_autocmds = extern struct { + event: Object, + group: Object, + pattern: Object, + buffer: Object, +}; +pub const KeyDict_create_augroup = extern struct { + clear: Object, +}; +pub const KeyDict_cmd = extern struct { + cmd: Object, + range: Object, + count: Object, + reg: Object, + bang: Object, + args: Object, + magic: Object, + mods: Object, + nargs: Object, + addr: Object, + nextcmd: Object, +}; +pub const KeyDict_cmd_magic = extern struct { + file: Object, + bar: Object, +}; +pub const KeyDict_cmd_mods = extern struct { + silent: Object, + emsg_silent: Object, + unsilent: Object, + filter: Object, + sandbox: Object, + noautocmd: Object, + browse: Object, + confirm: Object, + hide: Object, + horizontal: Object, + keepalt: Object, + keepjumps: Object, + keepmarks: Object, + keeppatterns: Object, + lockmarks: Object, + noswapfile: Object, + tab: Object, + verbose: Object, + vertical: Object, + split: Object, +}; +pub const KeyDict_cmd_mods_filter = extern struct { + pattern: Object, + force: Object, +}; +pub const KeyDict_cmd_opts = extern struct { + output: Object, +}; +pub const KeyDict_echo_opts = extern struct { + verbose: Object, +}; +pub const KeyDict_exec_opts = extern struct { + output: Object, +}; +pub extern fn nvim_get_autocmds(opts: [*c]KeyDict_get_autocmds, err: [*c]Error) Array; +pub extern fn nvim_create_autocmd(channel_id: u64, event: Object, opts: [*c]KeyDict_create_autocmd, err: [*c]Error) Integer; +pub extern fn nvim_del_autocmd(id: Integer, err: [*c]Error) void; +pub extern fn nvim_clear_autocmds(opts: [*c]KeyDict_clear_autocmds, err: [*c]Error) void; +pub extern fn nvim_create_augroup(channel_id: u64, name: String, opts: [*c]KeyDict_create_augroup, err: [*c]Error) Integer; +pub extern fn nvim_del_augroup_by_id(id: Integer, err: [*c]Error) void; +pub extern fn nvim_del_augroup_by_name(name: String, err: [*c]Error) void; +pub extern fn nvim_exec_autocmds(event: Object, opts: [*c]KeyDict_exec_autocmds, err: [*c]Error) void; +pub const struct_lua_State = opaque {}; +pub const lua_State = struct_lua_State; +pub const lua_Number = f64; +pub const lua_Integer = c_longlong; +pub const lua_Unsigned = c_ulonglong; +pub const lua_KContext = isize; +pub const lua_CFunction = ?*const fn (?*lua_State) callconv(.C) c_int; +pub const lua_KFunction = ?*const fn (?*lua_State, c_int, lua_KContext) callconv(.C) c_int; +pub const lua_Reader = ?*const fn (?*lua_State, ?*anyopaque, [*c]usize) callconv(.C) [*c]const u8; +pub const lua_Writer = ?*const fn (?*lua_State, ?*const anyopaque, usize, ?*anyopaque) callconv(.C) c_int; +pub const lua_Alloc = ?*const fn (?*anyopaque, ?*anyopaque, usize, usize) callconv(.C) ?*anyopaque; +pub const lua_WarnFunction = ?*const fn (?*anyopaque, [*c]const u8, c_int) callconv(.C) void; +pub const lua_ident: [*c]const u8 = @extern([*c]const u8, .{ + .name = "lua_ident", +}); +pub extern fn lua_newstate(f: lua_Alloc, ud: ?*anyopaque) ?*lua_State; +pub extern fn lua_close(L: ?*lua_State) void; +pub extern fn lua_newthread(L: ?*lua_State) ?*lua_State; +pub extern fn lua_resetthread(L: ?*lua_State) c_int; +pub extern fn lua_atpanic(L: ?*lua_State, panicf: lua_CFunction) lua_CFunction; +pub extern fn lua_version(L: ?*lua_State) lua_Number; +pub extern fn lua_absindex(L: ?*lua_State, idx: c_int) c_int; +pub extern fn lua_gettop(L: ?*lua_State) c_int; +pub extern fn lua_settop(L: ?*lua_State, idx: c_int) void; +pub extern fn lua_pushvalue(L: ?*lua_State, idx: c_int) void; +pub extern fn lua_rotate(L: ?*lua_State, idx: c_int, n: c_int) void; +pub extern fn lua_copy(L: ?*lua_State, fromidx: c_int, toidx: c_int) void; +pub extern fn lua_checkstack(L: ?*lua_State, n: c_int) c_int; +pub extern fn lua_xmove(from: ?*lua_State, to: ?*lua_State, n: c_int) void; +pub extern fn lua_isnumber(L: ?*lua_State, idx: c_int) c_int; +pub extern fn lua_isstring(L: ?*lua_State, idx: c_int) c_int; +pub extern fn lua_iscfunction(L: ?*lua_State, idx: c_int) c_int; +pub extern fn lua_isinteger(L: ?*lua_State, idx: c_int) c_int; +pub extern fn lua_isuserdata(L: ?*lua_State, idx: c_int) c_int; +pub extern fn lua_type(L: ?*lua_State, idx: c_int) c_int; +pub extern fn lua_typename(L: ?*lua_State, tp: c_int) [*c]const u8; +pub extern fn lua_tonumberx(L: ?*lua_State, idx: c_int, isnum: [*c]c_int) lua_Number; +pub extern fn lua_tointegerx(L: ?*lua_State, idx: c_int, isnum: [*c]c_int) lua_Integer; +pub extern fn lua_toboolean(L: ?*lua_State, idx: c_int) c_int; +pub extern fn lua_tolstring(L: ?*lua_State, idx: c_int, len: [*c]usize) [*c]const u8; +pub extern fn lua_rawlen(L: ?*lua_State, idx: c_int) lua_Unsigned; +pub extern fn lua_tocfunction(L: ?*lua_State, idx: c_int) lua_CFunction; +pub extern fn lua_touserdata(L: ?*lua_State, idx: c_int) ?*anyopaque; +pub extern fn lua_tothread(L: ?*lua_State, idx: c_int) ?*lua_State; +pub extern fn lua_topointer(L: ?*lua_State, idx: c_int) ?*const anyopaque; +pub extern fn lua_arith(L: ?*lua_State, op: c_int) void; +pub extern fn lua_rawequal(L: ?*lua_State, idx1: c_int, idx2: c_int) c_int; +pub extern fn lua_compare(L: ?*lua_State, idx1: c_int, idx2: c_int, op: c_int) c_int; +pub extern fn lua_pushnil(L: ?*lua_State) void; +pub extern fn lua_pushnumber(L: ?*lua_State, n: lua_Number) void; +pub extern fn lua_pushinteger(L: ?*lua_State, n: lua_Integer) void; +pub extern fn lua_pushlstring(L: ?*lua_State, s: [*c]const u8, len: usize) [*c]const u8; +pub extern fn lua_pushstring(L: ?*lua_State, s: [*c]const u8) [*c]const u8; +pub extern fn lua_pushvfstring(L: ?*lua_State, fmt: [*c]const u8, argp: [*c]struct___va_list_tag) [*c]const u8; +pub extern fn lua_pushfstring(L: ?*lua_State, fmt: [*c]const u8, ...) [*c]const u8; +pub extern fn lua_pushcclosure(L: ?*lua_State, @"fn": lua_CFunction, n: c_int) void; +pub extern fn lua_pushboolean(L: ?*lua_State, b: c_int) void; +pub extern fn lua_pushlightuserdata(L: ?*lua_State, p: ?*anyopaque) void; +pub extern fn lua_pushthread(L: ?*lua_State) c_int; +pub extern fn lua_getglobal(L: ?*lua_State, name: [*c]const u8) c_int; +pub extern fn lua_gettable(L: ?*lua_State, idx: c_int) c_int; +pub extern fn lua_getfield(L: ?*lua_State, idx: c_int, k: [*c]const u8) c_int; +pub extern fn lua_geti(L: ?*lua_State, idx: c_int, n: lua_Integer) c_int; +pub extern fn lua_rawget(L: ?*lua_State, idx: c_int) c_int; +pub extern fn lua_rawgeti(L: ?*lua_State, idx: c_int, n: lua_Integer) c_int; +pub extern fn lua_rawgetp(L: ?*lua_State, idx: c_int, p: ?*const anyopaque) c_int; +pub extern fn lua_createtable(L: ?*lua_State, narr: c_int, nrec: c_int) void; +pub extern fn lua_newuserdatauv(L: ?*lua_State, sz: usize, nuvalue: c_int) ?*anyopaque; +pub extern fn lua_getmetatable(L: ?*lua_State, objindex: c_int) c_int; +pub extern fn lua_getiuservalue(L: ?*lua_State, idx: c_int, n: c_int) c_int; +pub extern fn lua_setglobal(L: ?*lua_State, name: [*c]const u8) void; +pub extern fn lua_settable(L: ?*lua_State, idx: c_int) void; +pub extern fn lua_setfield(L: ?*lua_State, idx: c_int, k: [*c]const u8) void; +pub extern fn lua_seti(L: ?*lua_State, idx: c_int, n: lua_Integer) void; +pub extern fn lua_rawset(L: ?*lua_State, idx: c_int) void; +pub extern fn lua_rawseti(L: ?*lua_State, idx: c_int, n: lua_Integer) void; +pub extern fn lua_rawsetp(L: ?*lua_State, idx: c_int, p: ?*const anyopaque) void; +pub extern fn lua_setmetatable(L: ?*lua_State, objindex: c_int) c_int; +pub extern fn lua_setiuservalue(L: ?*lua_State, idx: c_int, n: c_int) c_int; +pub extern fn lua_callk(L: ?*lua_State, nargs: c_int, nresults: c_int, ctx: lua_KContext, k: lua_KFunction) void; +pub extern fn lua_pcallk(L: ?*lua_State, nargs: c_int, nresults: c_int, errfunc: c_int, ctx: lua_KContext, k: lua_KFunction) c_int; +pub extern fn lua_load(L: ?*lua_State, reader: lua_Reader, dt: ?*anyopaque, chunkname: [*c]const u8, mode: [*c]const u8) c_int; +pub extern fn lua_dump(L: ?*lua_State, writer: lua_Writer, data: ?*anyopaque, strip: c_int) c_int; +pub extern fn lua_yieldk(L: ?*lua_State, nresults: c_int, ctx: lua_KContext, k: lua_KFunction) c_int; +pub extern fn lua_resume(L: ?*lua_State, from: ?*lua_State, narg: c_int, nres: [*c]c_int) c_int; +pub extern fn lua_status(L: ?*lua_State) c_int; +pub extern fn lua_isyieldable(L: ?*lua_State) c_int; +pub extern fn lua_setwarnf(L: ?*lua_State, f: lua_WarnFunction, ud: ?*anyopaque) void; +pub extern fn lua_warning(L: ?*lua_State, msg: [*c]const u8, tocont: c_int) void; +pub extern fn lua_gc(L: ?*lua_State, what: c_int, ...) c_int; +pub extern fn lua_error(L: ?*lua_State) c_int; +pub extern fn lua_next(L: ?*lua_State, idx: c_int) c_int; +pub extern fn lua_concat(L: ?*lua_State, n: c_int) void; +pub extern fn lua_len(L: ?*lua_State, idx: c_int) void; +pub extern fn lua_stringtonumber(L: ?*lua_State, s: [*c]const u8) usize; +pub extern fn lua_getallocf(L: ?*lua_State, ud: [*c]?*anyopaque) lua_Alloc; +pub extern fn lua_setallocf(L: ?*lua_State, f: lua_Alloc, ud: ?*anyopaque) void; +pub extern fn lua_toclose(L: ?*lua_State, idx: c_int) void; +pub extern fn lua_closeslot(L: ?*lua_State, idx: c_int) void; +pub const struct_CallInfo = opaque {}; +pub const struct_lua_Debug = extern struct { + event: c_int, + name: [*c]const u8, + namewhat: [*c]const u8, + what: [*c]const u8, + source: [*c]const u8, + srclen: usize, + currentline: c_int, + linedefined: c_int, + lastlinedefined: c_int, + nups: u8, + nparams: u8, + isvararg: u8, + istailcall: u8, + ftransfer: c_ushort, + ntransfer: c_ushort, + short_src: [60]u8, + i_ci: ?*struct_CallInfo, +}; +pub const lua_Debug = struct_lua_Debug; +pub const lua_Hook = ?*const fn (?*lua_State, [*c]lua_Debug) callconv(.C) void; +pub extern fn lua_getstack(L: ?*lua_State, level: c_int, ar: [*c]lua_Debug) c_int; +pub extern fn lua_getinfo(L: ?*lua_State, what: [*c]const u8, ar: [*c]lua_Debug) c_int; +pub extern fn lua_getlocal(L: ?*lua_State, ar: [*c]const lua_Debug, n: c_int) [*c]const u8; +pub extern fn lua_setlocal(L: ?*lua_State, ar: [*c]const lua_Debug, n: c_int) [*c]const u8; +pub extern fn lua_getupvalue(L: ?*lua_State, funcindex: c_int, n: c_int) [*c]const u8; +pub extern fn lua_setupvalue(L: ?*lua_State, funcindex: c_int, n: c_int) [*c]const u8; +pub extern fn lua_upvalueid(L: ?*lua_State, fidx: c_int, n: c_int) ?*anyopaque; +pub extern fn lua_upvaluejoin(L: ?*lua_State, fidx1: c_int, n1: c_int, fidx2: c_int, n2: c_int) void; +pub extern fn lua_sethook(L: ?*lua_State, func: lua_Hook, mask: c_int, count: c_int) void; +pub extern fn lua_gethook(L: ?*lua_State) lua_Hook; +pub extern fn lua_gethookmask(L: ?*lua_State) c_int; +pub extern fn lua_gethookcount(L: ?*lua_State) c_int; +pub extern fn lua_setcstacklimit(L: ?*lua_State, limit: c_uint) c_int; +const union_unnamed_31 = extern union { + n: lua_Number, + u: f64, + s: ?*anyopaque, + i: lua_Integer, + l: c_long, + b: [1024]u8, +}; +pub const struct_luaL_Buffer = extern struct { + b: [*c]u8, + size: usize, + n: usize, + L: ?*lua_State, + init: union_unnamed_31, +}; +pub const luaL_Buffer = struct_luaL_Buffer; +pub const struct_luaL_Reg = extern struct { + name: [*c]const u8, + func: lua_CFunction, +}; +pub const luaL_Reg = struct_luaL_Reg; +pub extern fn luaL_checkversion_(L: ?*lua_State, ver: lua_Number, sz: usize) void; +pub extern fn luaL_getmetafield(L: ?*lua_State, obj: c_int, e: [*c]const u8) c_int; +pub extern fn luaL_callmeta(L: ?*lua_State, obj: c_int, e: [*c]const u8) c_int; +pub extern fn luaL_tolstring(L: ?*lua_State, idx: c_int, len: [*c]usize) [*c]const u8; +pub extern fn luaL_argerror(L: ?*lua_State, arg: c_int, extramsg: [*c]const u8) c_int; +pub extern fn luaL_typeerror(L: ?*lua_State, arg: c_int, tname: [*c]const u8) c_int; +pub extern fn luaL_checklstring(L: ?*lua_State, arg: c_int, l: [*c]usize) [*c]const u8; +pub extern fn luaL_optlstring(L: ?*lua_State, arg: c_int, def: [*c]const u8, l: [*c]usize) [*c]const u8; +pub extern fn luaL_checknumber(L: ?*lua_State, arg: c_int) lua_Number; +pub extern fn luaL_optnumber(L: ?*lua_State, arg: c_int, def: lua_Number) lua_Number; +pub extern fn luaL_checkinteger(L: ?*lua_State, arg: c_int) lua_Integer; +pub extern fn luaL_optinteger(L: ?*lua_State, arg: c_int, def: lua_Integer) lua_Integer; +pub extern fn luaL_checkstack(L: ?*lua_State, sz: c_int, msg: [*c]const u8) void; +pub extern fn luaL_checktype(L: ?*lua_State, arg: c_int, t: c_int) void; +pub extern fn luaL_checkany(L: ?*lua_State, arg: c_int) void; +pub extern fn luaL_newmetatable(L: ?*lua_State, tname: [*c]const u8) c_int; +pub extern fn luaL_setmetatable(L: ?*lua_State, tname: [*c]const u8) void; +pub extern fn luaL_testudata(L: ?*lua_State, ud: c_int, tname: [*c]const u8) ?*anyopaque; +pub extern fn luaL_checkudata(L: ?*lua_State, ud: c_int, tname: [*c]const u8) ?*anyopaque; +pub extern fn luaL_where(L: ?*lua_State, lvl: c_int) void; +pub extern fn luaL_error(L: ?*lua_State, fmt: [*c]const u8, ...) c_int; +pub extern fn luaL_checkoption(L: ?*lua_State, arg: c_int, def: [*c]const u8, lst: [*c]const [*c]const u8) c_int; +pub extern fn luaL_fileresult(L: ?*lua_State, stat: c_int, fname: [*c]const u8) c_int; +pub extern fn luaL_execresult(L: ?*lua_State, stat: c_int) c_int; +pub extern fn luaL_ref(L: ?*lua_State, t: c_int) c_int; +pub extern fn luaL_unref(L: ?*lua_State, t: c_int, ref: c_int) void; +pub extern fn luaL_loadfilex(L: ?*lua_State, filename: [*c]const u8, mode: [*c]const u8) c_int; +pub extern fn luaL_loadbufferx(L: ?*lua_State, buff: [*c]const u8, sz: usize, name: [*c]const u8, mode: [*c]const u8) c_int; +pub extern fn luaL_loadstring(L: ?*lua_State, s: [*c]const u8) c_int; +pub extern fn luaL_newstate() ?*lua_State; +pub extern fn luaL_len(L: ?*lua_State, idx: c_int) lua_Integer; +pub extern fn luaL_addgsub(b: [*c]luaL_Buffer, s: [*c]const u8, p: [*c]const u8, r: [*c]const u8) void; +pub extern fn luaL_gsub(L: ?*lua_State, s: [*c]const u8, p: [*c]const u8, r: [*c]const u8) [*c]const u8; +pub extern fn luaL_setfuncs(L: ?*lua_State, l: [*c]const luaL_Reg, nup: c_int) void; +pub extern fn luaL_getsubtable(L: ?*lua_State, idx: c_int, fname: [*c]const u8) c_int; +pub extern fn luaL_traceback(L: ?*lua_State, L1: ?*lua_State, msg: [*c]const u8, level: c_int) void; +pub extern fn luaL_requiref(L: ?*lua_State, modname: [*c]const u8, openf: lua_CFunction, glb: c_int) void; +pub extern fn luaL_buffinit(L: ?*lua_State, B: [*c]luaL_Buffer) void; +pub extern fn luaL_prepbuffsize(B: [*c]luaL_Buffer, sz: usize) [*c]u8; +pub extern fn luaL_addlstring(B: [*c]luaL_Buffer, s: [*c]const u8, l: usize) void; +pub extern fn luaL_addstring(B: [*c]luaL_Buffer, s: [*c]const u8) void; +pub extern fn luaL_addvalue(B: [*c]luaL_Buffer) void; +pub extern fn luaL_pushresult(B: [*c]luaL_Buffer) void; +pub extern fn luaL_pushresultsize(B: [*c]luaL_Buffer, sz: usize) void; +pub extern fn luaL_buffinitsize(L: ?*lua_State, B: [*c]luaL_Buffer, sz: usize) [*c]u8; +pub const struct_luaL_Stream = extern struct { + f: [*c]FILE, + closef: lua_CFunction, +}; +pub const luaL_Stream = struct_luaL_Stream; +pub const linenr_T = i32; +pub const blocknr_T = i64; +pub const struct_mf_hashitem = extern struct { + mhi_next: [*c]struct_mf_hashitem, + mhi_prev: [*c]struct_mf_hashitem, + mhi_key: blocknr_T, +}; +pub const mf_hashitem_T = struct_mf_hashitem; +pub const struct_bhdr = extern struct { + bh_hashitem: mf_hashitem_T, + bh_next: [*c]struct_bhdr, + bh_prev: [*c]struct_bhdr, + bh_data: ?*anyopaque, + bh_page_count: c_uint, + bh_flags: c_uint, +}; +pub const bhdr_T = struct_bhdr; +pub const struct_mf_hashtab = extern struct { + mht_mask: usize, + mht_count: usize, + mht_buckets: [*c][*c]mf_hashitem_T, + mht_small_buckets: [64][*c]mf_hashitem_T, +}; +pub const mf_hashtab_T = struct_mf_hashtab; +pub const struct_memfile = extern struct { + mf_fname: [*c]u8, + mf_ffname: [*c]u8, + mf_fd: c_int, + mf_free_first: [*c]bhdr_T, + mf_used_first: [*c]bhdr_T, + mf_used_last: [*c]bhdr_T, + mf_hash: mf_hashtab_T, + mf_trans: mf_hashtab_T, + mf_blocknr_max: blocknr_T, + mf_blocknr_min: blocknr_T, + mf_neg_count: blocknr_T, + mf_infile_count: blocknr_T, + mf_page_size: c_uint, + mf_dirty: bool, +}; +pub const memfile_T = struct_memfile; +pub const struct_info_pointer = extern struct { + ip_bnum: blocknr_T, + ip_low: linenr_T, + ip_high: linenr_T, + ip_index: c_int, +}; +pub const infoptr_T = struct_info_pointer; +pub const struct_ml_chunksize = extern struct { + mlcs_numlines: c_int, + mlcs_totalsize: c_long, +}; +pub const chunksize_T = struct_ml_chunksize; +pub const struct_memline = extern struct { + ml_line_count: linenr_T, + ml_mfp: [*c]memfile_T, + ml_stack: [*c]infoptr_T, + ml_stack_top: c_int, + ml_stack_size: c_int, + ml_flags: c_int, + ml_line_lnum: linenr_T, + ml_line_ptr: [*c]u8, + ml_line_offset: usize, + ml_line_offset_ff: c_int, + ml_locked: [*c]bhdr_T, + ml_locked_low: linenr_T, + ml_locked_high: linenr_T, + ml_locked_lineadd: c_int, + ml_chunksize: [*c]chunksize_T, + ml_numchunks: c_int, + ml_usedchunks: c_int, +}; +pub const memline_T = struct_memline; +pub const buf_T = struct_file_buffer; +pub const varnumber_T = i64; +pub const struct_frame_S = extern struct { + fr_layout: u8, + fr_width: c_int, + fr_newwidth: c_int, + fr_height: c_int, + fr_newheight: c_int, + fr_parent: [*c]frame_T, + fr_next: [*c]frame_T, + fr_prev: [*c]frame_T, + fr_child: [*c]frame_T, + fr_win: [*c]win_T, +}; +pub const frame_T = struct_frame_S; +pub const colnr_T = c_int; +const struct_unnamed_32 = extern struct { + eol: c_int, + ext: c_int, + prec: c_int, + nbsp: c_int, + space: c_int, + tab1: c_int, + tab2: c_int, + tab3: c_int, + lead: c_int, + trail: c_int, + multispace: [*c]c_int, + leadmultispace: [*c]c_int, + conceal: c_int, +}; +const struct_unnamed_33 = extern struct { + stl: c_int, + stlnc: c_int, + wbr: c_int, + horiz: c_int, + horizup: c_int, + horizdown: c_int, + vert: c_int, + vertleft: c_int, + vertright: c_int, + verthoriz: c_int, + fold: c_int, + foldopen: c_int, + foldclosed: c_int, + foldsep: c_int, + diff: c_int, + msgsep: c_int, + eob: c_int, + lastline: c_int, +}; +pub const struct_w_line = extern struct { + wl_lnum: linenr_T, + wl_size: u16, + wl_valid: u8, + wl_folded: u8, + wl_lastlnum: linenr_T, +}; +pub const wline_T = struct_w_line; +pub const struct_growarray = extern struct { + ga_len: c_int, + ga_maxlen: c_int, + ga_itemsize: c_int, + ga_growsize: c_int, + ga_data: ?*anyopaque, +}; +pub const garray_T = struct_growarray; +pub const struct_arglist = extern struct { + al_ga: garray_T, + al_refcount: c_int, + id: c_int, +}; +pub const alist_T = struct_arglist; +pub const hash_T = usize; +pub const struct_hashitem_S = extern struct { + hi_hash: hash_T, + hi_key: [*c]u8, +}; +pub const hashitem_T = struct_hashitem_S; +pub const struct_hashtable_S = extern struct { + ht_mask: hash_T, + ht_used: usize, + ht_filled: usize, + ht_changed: c_int, + ht_locked: c_int, + ht_array: [*c]hashitem_T, + ht_smallarray: [16]hashitem_T, +}; +pub const hashtab_T = struct_hashtable_S; +pub const struct__queue = extern struct { + next: [*c]struct__queue, + prev: [*c]struct__queue, +}; +pub const QUEUE = struct__queue; +pub const struct_dictvar_S = extern struct { + dv_lock: VarLockStatus, + dv_scope: ScopeType, + dv_refcount: c_int, + dv_copyID: c_int, + dv_hashtab: hashtab_T, + dv_copydict: [*c]dict_T, + dv_used_next: [*c]dict_T, + dv_used_prev: [*c]dict_T, + watchers: QUEUE, + lua_table_ref: LuaRef, +}; +pub const dict_T = struct_dictvar_S; +pub const Timestamp = u64; +pub const struct_fmarkv = extern struct { + topline_offset: linenr_T, +}; +pub const fmarkv_T = struct_fmarkv; +pub const struct_filemark = extern struct { + mark: pos_T, + fnum: c_int, + timestamp: Timestamp, + view: fmarkv_T, + additional_data: [*c]dict_T, +}; +pub const fmark_T = struct_filemark; +pub const struct_xfilemark = extern struct { + fmark: fmark_T, + fname: [*c]u8, +}; +pub const xfmark_T = struct_xfilemark; +pub const struct_matchitem = extern struct { + mit_next: [*c]matchitem_T, + mit_id: c_int, + mit_priority: c_int, + mit_pattern: [*c]u8, + mit_match: regmmatch_T, + mit_pos_array: [*c]llpos_T, + mit_pos_count: c_int, + mit_pos_cur: c_int, + mit_toplnum: linenr_T, + mit_botlnum: linenr_T, + mit_hl: match_T, + mit_hlg_id: c_int, + mit_conceal_char: c_int, +}; +pub const matchitem_T = struct_matchitem; +pub const struct_taggy = extern struct { + tagname: [*c]u8, + fmark: fmark_T, + cur_match: c_int, + cur_fnum: c_int, + user_data: [*c]u8, +}; +pub const taggy_T = struct_taggy; +pub const schar_T = [29]u8; +pub const sattr_T = c_int; +pub const struct_ScreenGrid = extern struct { + handle: handle_T, + chars: [*c]schar_T, + attrs: [*c]sattr_T, + line_offset: [*c]usize, + line_wraps: [*c]u8, + dirty_col: [*c]c_int, + rows: c_int, + cols: c_int, + valid: bool, + throttled: bool, + row_offset: c_int, + col_offset: c_int, + target: [*c]ScreenGrid, + blending: bool, + focusable: bool, + zindex: c_int, + comp_row: c_int, + comp_col: c_int, + comp_width: c_int, + comp_height: c_int, + comp_index: usize, + comp_disabled: bool, +}; +pub const ScreenGrid = struct_ScreenGrid; +pub const struct_qf_info_S = opaque {}; +pub const qf_info_T = struct_qf_info_S; +pub const struct_window_S = extern struct { + handle: handle_T, + w_buffer: [*c]buf_T, + w_s: [*c]synblock_T, + w_ns_hl: c_int, + w_ns_hl_winhl: c_int, + w_ns_hl_active: c_int, + w_ns_hl_attr: [*c]c_int, + w_hl_id_normal: c_int, + w_hl_attr_normal: c_int, + w_hl_attr_normalnc: c_int, + w_hl_needs_update: c_int, + w_prev: [*c]win_T, + w_next: [*c]win_T, + w_closing: bool, + w_frame: [*c]frame_T, + w_cursor: pos_T, + w_curswant: colnr_T, + w_set_curswant: c_int, + w_cursorline: linenr_T, + w_last_cursorline: linenr_T, + w_last_cursormoved: pos_T, + w_old_visual_mode: u8, + w_old_cursor_lnum: linenr_T, + w_old_cursor_fcol: colnr_T, + w_old_cursor_lcol: colnr_T, + w_old_visual_lnum: linenr_T, + w_old_visual_col: colnr_T, + w_old_curswant: colnr_T, + w_last_cursor_lnum_rnu: linenr_T, + w_p_lcs_chars: struct_unnamed_32, + w_p_fcs_chars: struct_unnamed_33, + w_topline: linenr_T, + w_topline_was_set: u8, + w_topfill: c_int, + w_old_topfill: c_int, + w_botfill: bool, + w_old_botfill: bool, + w_leftcol: colnr_T, + w_skipcol: colnr_T, + w_last_topline: linenr_T, + w_last_topfill: c_int, + w_last_leftcol: colnr_T, + w_last_skipcol: colnr_T, + w_last_width: c_int, + w_last_height: c_int, + w_winrow: c_int, + w_height: c_int, + w_prev_winrow: c_int, + w_prev_height: c_int, + w_status_height: c_int, + w_winbar_height: c_int, + w_wincol: c_int, + w_width: c_int, + w_hsep_height: c_int, + w_vsep_width: c_int, + w_save_cursor: pos_save_T, + w_winrow_off: c_int, + w_wincol_off: c_int, + w_height_inner: c_int, + w_width_inner: c_int, + w_height_request: c_int, + w_width_request: c_int, + w_border_adj: [4]c_int, + w_height_outer: c_int, + w_width_outer: c_int, + w_valid: c_int, + w_valid_cursor: pos_T, + w_valid_leftcol: colnr_T, + w_viewport_invalid: bool, + w_viewport_last_topline: linenr_T, + w_cline_height: c_int, + w_cline_folded: bool, + w_cline_row: c_int, + w_virtcol: colnr_T, + w_wrow: c_int, + w_wcol: c_int, + w_botline: linenr_T, + w_empty_rows: c_int, + w_filler_rows: c_int, + w_lines_valid: c_int, + w_lines: [*c]wline_T, + w_folds: garray_T, + w_fold_manual: bool, + w_foldinvalid: bool, + w_nrwidth: c_int, + w_scwidth: c_int, + w_redr_type: c_int, + w_upd_rows: c_int, + w_redraw_top: linenr_T, + w_redraw_bot: linenr_T, + w_redr_status: bool, + w_redr_border: bool, + w_redr_statuscol: bool, + w_stl_cursor: pos_T, + w_stl_virtcol: colnr_T, + w_stl_topline: linenr_T, + w_stl_line_count: linenr_T, + w_stl_topfill: c_int, + w_stl_empty: u8, + w_stl_state: c_int, + w_stl_recording: c_int, + w_alt_fnum: c_int, + w_alist: [*c]alist_T, + w_arg_idx: c_int, + w_arg_idx_invalid: c_int, + w_localdir: [*c]u8, + w_prevdir: [*c]u8, + w_onebuf_opt: winopt_T, + w_allbuf_opt: winopt_T, + w_p_stl_flags: u32, + w_p_wbr_flags: u32, + w_p_fde_flags: u32, + w_p_fdt_flags: u32, + w_p_cc_cols: [*c]c_int, + w_p_culopt_flags: u8, + w_p_siso: c_long, + w_p_so: c_long, + w_briopt_min: c_int, + w_briopt_shift: c_int, + w_briopt_sbr: bool, + w_briopt_list: c_int, + w_briopt_vcol: c_int, + w_scbind_pos: c_long, + w_winvar: ScopeDictDictItem, + w_vars: [*c]dict_T, + w_pcmark: pos_T, + w_prev_pcmark: pos_T, + w_jumplist: [100]xfmark_T, + w_jumplistlen: c_int, + w_jumplistidx: c_int, + w_changelistidx: c_int, + w_match_head: [*c]matchitem_T, + w_next_match_id: c_int, + w_tagstack: [20]taggy_T, + w_tagstackidx: c_int, + w_tagstacklen: c_int, + w_grid: ScreenGrid, + w_grid_alloc: ScreenGrid, + w_pos_changed: bool, + w_floating: bool, + w_float_config: FloatConfig, + w_fraction: c_int, + w_prev_fraction_row: c_int, + w_nrwidth_line_count: linenr_T, + w_statuscol_line_count: linenr_T, + w_nrwidth_width: c_int, + w_llist: ?*qf_info_T, + w_llist_ref: ?*qf_info_T, + w_status_click_defs: [*c]StlClickDefinition, + w_status_click_defs_size: usize, + w_winbar_click_defs: [*c]StlClickDefinition, + w_winbar_click_defs_size: usize, + w_statuscol_click_defs: [*c]StlClickDefinition, + w_statuscol_click_defs_size: usize, +}; +pub const win_T = struct_window_S; +pub const struct_wininfo_S = extern struct { + wi_next: [*c]wininfo_T, + wi_prev: [*c]wininfo_T, + wi_win: [*c]win_T, + wi_mark: fmark_T, + wi_optset: bool, + wi_opt: winopt_T, + wi_fold_manual: bool, + wi_folds: garray_T, + wi_changelistidx: c_int, +}; +pub const wininfo_T = struct_wininfo_S; +pub const disptick_T = u64; +pub const struct_mapblock = extern struct { + m_next: [*c]mapblock_T, + m_keys: [*c]u8, + m_str: [*c]u8, + m_orig_str: [*c]u8, + m_luaref: LuaRef, + m_keylen: c_int, + m_mode: c_int, + m_simplified: c_int, + m_noremap: c_int, + m_silent: u8, + m_nowait: u8, + m_expr: u8, + m_script_ctx: sctx_T, + m_desc: [*c]u8, + m_replace_keycodes: bool, +}; +pub const mapblock_T = struct_mapblock; +const union_unnamed_34 = extern union { + ptr: [*c]u_header_T, + seq: c_long, +}; +const union_unnamed_35 = extern union { + ptr: [*c]u_header_T, + seq: c_long, +}; +const union_unnamed_36 = extern union { + ptr: [*c]u_header_T, + seq: c_long, +}; +const union_unnamed_37 = extern union { + ptr: [*c]u_header_T, + seq: c_long, +}; +pub const struct_u_entry = extern struct { + ue_next: [*c]u_entry_T, + ue_top: linenr_T, + ue_bot: linenr_T, + ue_lcount: linenr_T, + ue_array: [*c][*c]u8, + ue_size: c_long, +}; +pub const u_entry_T = struct_u_entry; +pub const struct_u_header = extern struct { + uh_next: union_unnamed_34, + uh_prev: union_unnamed_35, + uh_alt_next: union_unnamed_36, + uh_alt_prev: union_unnamed_37, + uh_seq: c_long, + uh_walk: c_int, + uh_entry: [*c]u_entry_T, + uh_getbot_entry: [*c]u_entry_T, + uh_cursor: pos_T, + uh_cursor_vcol: c_long, + uh_flags: c_int, + uh_namedm: [26]fmark_T, + uh_extmark: extmark_undo_vec_t, + uh_visual: visualinfo_T, + uh_time: time_t, + uh_save_nr: c_long, +}; +pub const u_header_T = struct_u_header; +pub const struct_signgroup_S = extern struct { + sg_next_sign_id: c_int align(4), + sg_refcount: u16, + pub fn sg_name(self: anytype) @import("std").zig.c_translation.FlexibleArrayType(@TypeOf(self), u8) { + const Intermediate = @import("std").zig.c_translation.FlexibleArrayType(@TypeOf(self), u8); + const ReturnType = @import("std").zig.c_translation.FlexibleArrayType(@TypeOf(self), u8); + return @ptrCast(ReturnType, @alignCast(@alignOf(u8), @ptrCast(Intermediate, self) + 6)); + } +}; +pub const signgroup_T = struct_signgroup_S; +pub const struct_sign_entry = extern struct { + se_id: c_int, + se_typenr: c_int, + se_priority: c_int, + se_has_text_or_icon: bool, + se_lnum: linenr_T, + se_group: [*c]signgroup_T, + se_next: [*c]sign_entry_T, + se_prev: [*c]sign_entry_T, +}; +pub const sign_entry_T = struct_sign_entry; +const struct_unnamed_38 = extern struct { + size: c_int, + valid: bool, + sentinel: linenr_T, + max: c_int, +}; +pub const struct_terminal = opaque {}; +pub const Terminal = struct_terminal; +const struct_unnamed_39 = extern struct { + size: usize, + capacity: usize, + items: [*c]u64, +}; +const struct_unnamed_40 = extern struct { + size: usize, + capacity: usize, + items: [*c]BufUpdateCallbacks, +}; +pub const struct_file_buffer = extern struct { + handle: handle_T, + b_ml: memline_T, + b_next: [*c]buf_T, + b_prev: [*c]buf_T, + b_nwindows: c_int, + b_flags: c_int, + b_locked: c_int, + b_locked_split: c_int, + b_ro_locked: c_int, + b_ffname: [*c]u8, + b_sfname: [*c]u8, + b_fname: [*c]u8, + file_id_valid: bool, + file_id: FileID, + b_changed: c_int, + b_changed_invalid: bool, + changedtick_di: ChangedtickDictItem, + b_last_changedtick: varnumber_T, + b_last_changedtick_pum: varnumber_T, + b_saving: bool, + b_mod_set: bool, + b_mod_top: linenr_T, + b_mod_bot: linenr_T, + b_mod_xlines: linenr_T, + b_wininfo: [*c]wininfo_T, + b_mod_tick_syn: disptick_T, + b_mod_tick_decor: disptick_T, + b_mtime: c_long, + b_mtime_ns: c_long, + b_mtime_read: c_long, + b_mtime_read_ns: c_long, + b_orig_size: u64, + b_orig_mode: c_int, + b_last_used: time_t, + b_namedm: [26]fmark_T, + b_visual: visualinfo_T, + b_visual_mode_eval: c_int, + b_last_cursor: fmark_T, + b_last_insert: fmark_T, + b_last_change: fmark_T, + b_changelist: [100]fmark_T, + b_changelistlen: c_int, + b_new_change: bool, + b_chartab: [4]u64, + b_maphash: [256][*c]mapblock_T, + b_first_abbr: [*c]mapblock_T, + b_ucmds: garray_T, + b_op_start: pos_T, + b_op_start_orig: pos_T, + b_op_end: pos_T, + b_marks_read: bool, + b_u_oldhead: [*c]u_header_T, + b_u_newhead: [*c]u_header_T, + b_u_curhead: [*c]u_header_T, + b_u_numhead: c_int, + b_u_synced: bool, + b_u_seq_last: c_long, + b_u_save_nr_last: c_long, + b_u_seq_cur: c_long, + b_u_time_cur: time_t, + b_u_save_nr_cur: c_long, + b_u_line_ptr: [*c]u8, + b_u_line_lnum: linenr_T, + b_u_line_colnr: colnr_T, + b_scanned: bool, + b_p_iminsert: c_long, + b_p_imsearch: c_long, + b_kmap_state: i16, + b_kmap_ga: garray_T, + b_p_initialized: bool, + b_p_script_ctx: [88]LastSet, + b_p_ai: c_int, + b_p_ai_nopaste: c_int, + b_p_bkc: [*c]u8, + b_bkc_flags: c_uint, + b_p_ci: c_int, + b_p_bin: c_int, + b_p_bomb: c_int, + b_p_bh: [*c]u8, + b_p_bt: [*c]u8, + b_has_qf_entry: c_int, + b_p_bl: c_int, + b_p_channel: c_long, + b_p_cin: c_int, + b_p_cino: [*c]u8, + b_p_cink: [*c]u8, + b_p_cinw: [*c]u8, + b_p_cinsd: [*c]u8, + b_p_com: [*c]u8, + b_p_cms: [*c]u8, + b_p_cpt: [*c]u8, + b_p_cfu: [*c]u8, + b_cfu_cb: Callback, + b_p_ofu: [*c]u8, + b_ofu_cb: Callback, + b_p_tfu: [*c]u8, + b_tfu_cb: Callback, + b_p_eof: c_int, + b_p_eol: c_int, + b_p_fixeol: c_int, + b_p_et: c_int, + b_p_et_nobin: c_int, + b_p_et_nopaste: c_int, + b_p_fenc: [*c]u8, + b_p_ff: [*c]u8, + b_p_ft: [*c]u8, + b_p_fo: [*c]u8, + b_p_flp: [*c]u8, + b_p_inf: c_int, + b_p_isk: [*c]u8, + b_p_def: [*c]u8, + b_p_inc: [*c]u8, + b_p_inex: [*c]u8, + b_p_inex_flags: u32, + b_p_inde: [*c]u8, + b_p_inde_flags: u32, + b_p_indk: [*c]u8, + b_p_fp: [*c]u8, + b_p_fex: [*c]u8, + b_p_fex_flags: u32, + b_p_kp: [*c]u8, + b_p_lisp: c_int, + b_p_lop: [*c]u8, + b_p_menc: [*c]u8, + b_p_mps: [*c]u8, + b_p_ml: c_int, + b_p_ml_nobin: c_int, + b_p_ma: c_int, + b_p_nf: [*c]u8, + b_p_pi: c_int, + b_p_qe: [*c]u8, + b_p_ro: c_int, + b_p_sw: c_long, + b_p_scbk: c_long, + b_p_si: c_int, + b_p_sts: c_long, + b_p_sts_nopaste: c_long, + b_p_sua: [*c]u8, + b_p_swf: c_int, + b_p_smc: c_long, + b_p_syn: [*c]u8, + b_p_ts: c_long, + b_p_tw: c_long, + b_p_tw_nobin: c_long, + b_p_tw_nopaste: c_long, + b_p_wm: c_long, + b_p_wm_nobin: c_long, + b_p_wm_nopaste: c_long, + b_p_vsts: [*c]u8, + b_p_vsts_array: [*c]c_long, + b_p_vsts_nopaste: [*c]u8, + b_p_vts: [*c]u8, + b_p_vts_array: [*c]c_long, + b_p_keymap: [*c]u8, + b_p_gp: [*c]u8, + b_p_mp: [*c]u8, + b_p_efm: [*c]u8, + b_p_ep: [*c]u8, + b_p_path: [*c]u8, + b_p_ar: c_int, + b_p_tags: [*c]u8, + b_p_tc: [*c]u8, + b_tc_flags: c_uint, + b_p_dict: [*c]u8, + b_p_tsr: [*c]u8, + b_p_tsrfu: [*c]u8, + b_tsrfu_cb: Callback, + b_p_ul: c_long, + b_p_udf: c_int, + b_p_lw: [*c]u8, + b_ind_level: c_int, + b_ind_open_imag: c_int, + b_ind_no_brace: c_int, + b_ind_first_open: c_int, + b_ind_open_extra: c_int, + b_ind_close_extra: c_int, + b_ind_open_left_imag: c_int, + b_ind_jump_label: c_int, + b_ind_case: c_int, + b_ind_case_code: c_int, + b_ind_case_break: c_int, + b_ind_param: c_int, + b_ind_func_type: c_int, + b_ind_comment: c_int, + b_ind_in_comment: c_int, + b_ind_in_comment2: c_int, + b_ind_cpp_baseclass: c_int, + b_ind_continuation: c_int, + b_ind_unclosed: c_int, + b_ind_unclosed2: c_int, + b_ind_unclosed_noignore: c_int, + b_ind_unclosed_wrapped: c_int, + b_ind_unclosed_whiteok: c_int, + b_ind_matching_paren: c_int, + b_ind_paren_prev: c_int, + b_ind_maxparen: c_int, + b_ind_maxcomment: c_int, + b_ind_scopedecl: c_int, + b_ind_scopedecl_code: c_int, + b_ind_java: c_int, + b_ind_js: c_int, + b_ind_keep_case_label: c_int, + b_ind_hash_comment: c_int, + b_ind_cpp_namespace: c_int, + b_ind_if_for_while: c_int, + b_ind_cpp_extern_c: c_int, + b_ind_pragma: c_int, + b_no_eol_lnum: linenr_T, + b_start_eof: c_int, + b_start_eol: c_int, + b_start_ffc: c_int, + b_start_fenc: [*c]u8, + b_bad_char: c_int, + b_start_bomb: c_int, + b_bufvar: ScopeDictDictItem, + b_vars: [*c]dict_T, + b_may_swap: bool, + b_did_warn: bool, + b_help: bool, + b_spell: bool, + b_prompt_text: [*c]u8, + b_prompt_callback: Callback, + b_prompt_interrupt: Callback, + b_prompt_insert: c_int, + b_s: synblock_T, + b_signlist: [*c]sign_entry_T, + b_signcols: struct_unnamed_38, + terminal: ?*Terminal, + additional_data: [*c]dict_T, + b_mapped_ctrl_c: c_int, + b_marktree: [1]MarkTree, + b_extmark_ns: [1]Map_uint32_t_uint32_t, + b_virt_line_blocks: usize, + b_signs: usize, + b_signs_with_text: usize, + update_channels: struct_unnamed_39, + update_callbacks: struct_unnamed_40, + update_need_codepoints: bool, + deleted_bytes: usize, + deleted_bytes2: usize, + deleted_codepoints: usize, + deleted_codeunits: usize, + flush_count: c_int, + b_diff_failed: c_int, +}; +pub const bufref_T = extern struct { + br_buf: [*c]buf_T, + br_fnum: c_int, + br_buf_free_count: c_int, +}; +pub extern fn __assert_fail(__assertion: [*c]const u8, __file: [*c]const u8, __line: c_uint, __function: [*c]const u8) noreturn; +pub extern fn __assert_perror_fail(__errnum: c_int, __file: [*c]const u8, __line: c_uint, __function: [*c]const u8) noreturn; +pub extern fn __assert(__assertion: [*c]const u8, __file: [*c]const u8, __line: c_int) noreturn; +pub const __gwchar_t = c_int; +pub const imaxdiv_t = extern struct { + quot: c_long, + rem: c_long, +}; +pub extern fn imaxabs(__n: intmax_t) intmax_t; +pub extern fn imaxdiv(__numer: intmax_t, __denom: intmax_t) imaxdiv_t; +pub extern fn strtoimax(noalias __nptr: [*c]const u8, noalias __endptr: [*c][*c]u8, __base: c_int) intmax_t; +pub extern fn strtoumax(noalias __nptr: [*c]const u8, noalias __endptr: [*c][*c]u8, __base: c_int) uintmax_t; +pub extern fn wcstoimax(noalias __nptr: [*c]const __gwchar_t, noalias __endptr: [*c][*c]__gwchar_t, __base: c_int) intmax_t; +pub extern fn wcstoumax(noalias __nptr: [*c]const __gwchar_t, noalias __endptr: [*c][*c]__gwchar_t, __base: c_int) uintmax_t; +pub extern var __sdt_unsp: c_ulonglong; +pub extern fn log_init() void; +pub extern fn log_lock() void; +pub extern fn log_unlock() void; +pub extern fn logmsg(log_level: c_int, context: [*c]const u8, func_name: [*c]const u8, line_num: c_int, eol: bool, fmt: [*c]const u8, ...) bool; +pub extern fn log_uv_handles(loop: ?*anyopaque) void; +pub extern fn open_log_file() [*c]FILE; +pub extern fn log_callstack_to_file(log_file: [*c]FILE, func_name: [*c]const u8, line_num: c_int) void; +pub extern fn log_callstack(func_name: [*c]const u8, line_num: c_int) void; +pub extern fn ga_clear(gap: [*c]garray_T) void; +pub extern fn ga_clear_strings(gap: [*c]garray_T) void; +pub extern fn ga_init(gap: [*c]garray_T, itemsize: c_int, growsize: c_int) void; +pub extern fn ga_set_growsize(gap: [*c]garray_T, growsize: c_int) void; +pub extern fn ga_grow(gap: [*c]garray_T, n: c_int) void; +pub extern fn ga_remove_duplicate_strings(gap: [*c]garray_T) void; +pub extern fn ga_concat_strings_sep(gap: [*c]const garray_T, sep: [*c]const u8) [*c]u8; +pub extern fn ga_concat_strings(gap: [*c]const garray_T) [*c]u8; +pub extern fn ga_concat(gap: [*c]garray_T, noalias s: [*c]const u8) void; +pub extern fn ga_concat_len(gap: [*c]garray_T, noalias s: [*c]const u8, len: usize) void; +pub extern fn ga_append(gap: [*c]garray_T, c: u8) void; +pub fn ga_append_via_ptr(arg_gap: [*c]garray_T, arg_item_size: usize) callconv(.C) ?*anyopaque { + var gap = arg_gap; + var item_size = arg_item_size; + if (@bitCast(c_int, @truncate(c_uint, item_size)) != gap.*.ga_itemsize) { + _ = logmsg(@as(c_int, 3), null, "ga_append_via_ptr", @as(c_int, 44), @as(c_int, 1) != 0, "wrong item size (%zu), should be %d", item_size, gap.*.ga_itemsize); + } + ga_grow(gap, @as(c_int, 1)); + return @ptrCast(?*anyopaque, @ptrCast([*c]u8, @alignCast(@import("std").meta.alignment([*c]u8), gap.*.ga_data)) + (item_size *% @bitCast(usize, @as(c_long, blk: { + const ref = &gap.*.ga_len; + const tmp = ref.*; + ref.* += 1; + break :blk tmp; + })))); +} +pub extern var hash_removed: u8; +pub extern fn hash_init(ht: [*c]hashtab_T) void; +pub extern fn hash_clear(ht: [*c]hashtab_T) void; +pub extern fn hash_clear_all(ht: [*c]hashtab_T, off: c_uint) void; +pub extern fn hash_find(ht: [*c]const hashtab_T, key: [*c]const u8) [*c]hashitem_T; +pub extern fn hash_find_len(ht: [*c]const hashtab_T, key: [*c]const u8, len: usize) [*c]hashitem_T; +pub extern fn hash_lookup(ht: [*c]const hashtab_T, key: [*c]const u8, key_len: usize, hash: hash_T) [*c]hashitem_T; +pub extern fn hash_debug_results() void; +pub extern fn hash_add(ht: [*c]hashtab_T, key: [*c]u8) c_int; +pub extern fn hash_add_item(ht: [*c]hashtab_T, hi: [*c]hashitem_T, key: [*c]u8, hash: hash_T) void; +pub extern fn hash_remove(ht: [*c]hashtab_T, hi: [*c]hashitem_T) void; +pub extern fn hash_lock(ht: [*c]hashtab_T) void; +pub extern fn hash_unlock(ht: [*c]hashtab_T) void; +pub extern fn hash_hash(key: [*c]const u8) hash_T; +pub extern fn hash_hash_len(key: [*c]const u8, len: usize) hash_T; +pub extern fn _hash_key_removed() [*c]const u8; +pub fn QUEUE_EMPTY(q: [*c]const QUEUE) callconv(.C) c_int { + return @boolToInt(q == @ptrCast([*c]const QUEUE, @alignCast(@import("std").meta.alignment([*c]const QUEUE), q.*.next))); +} +pub fn QUEUE_INIT(q: [*c]QUEUE) callconv(.C) void { + q.*.next = q; + q.*.prev = q; +} +pub fn QUEUE_ADD(h: [*c]QUEUE, n: [*c]QUEUE) callconv(.C) void { + h.*.prev.*.next = n.*.next; + n.*.next.*.prev = h.*.prev; + h.*.prev = n.*.prev; + h.*.prev.*.next = h; +} +pub fn QUEUE_INSERT_HEAD(h: [*c]QUEUE, q: [*c]QUEUE) callconv(.C) void { + q.*.next = h.*.next; + q.*.prev = h; + q.*.next.*.prev = q; + h.*.next = q; +} +pub fn QUEUE_INSERT_TAIL(h: [*c]QUEUE, q: [*c]QUEUE) callconv(.C) void { + q.*.next = h; + q.*.prev = h.*.prev; + q.*.prev.*.next = q; + h.*.prev = q; +} +pub fn QUEUE_REMOVE(q: [*c]QUEUE) callconv(.C) void { + q.*.prev.*.next = q.*.next; + q.*.next.*.prev = q.*.prev; +} +pub const MAXLNUM: c_int = 2147483647; +const enum_unnamed_41 = c_uint; +pub const MAXCOL: c_int = 2147483647; +const enum_unnamed_42 = c_uint; +pub const MINLNUM: c_int = 1; +const enum_unnamed_43 = c_uint; +pub const MINCOL: c_int = 1; +const enum_unnamed_44 = c_uint; +pub const pos_T = extern struct { + lnum: linenr_T, + col: colnr_T, + coladd: colnr_T, +}; +pub const lpos_T = extern struct { + lnum: linenr_T, + col: colnr_T, +}; +pub const uvarnumber_T = u64; +pub const DO_NOT_FREE_CNT: c_int = 1073741823; +const enum_unnamed_45 = c_uint; +pub const kListLenUnknown: c_int = -1; +pub const kListLenShouldKnow: c_int = -2; +pub const kListLenMayKnow: c_int = -3; +pub const enum_ListLenSpecials = c_int; +pub const struct_listitem_S = extern struct { + li_next: [*c]listitem_T, + li_prev: [*c]listitem_T, + li_tv: typval_T, +}; +pub const listitem_T = struct_listitem_S; +pub const struct_listwatch_S = extern struct { + lw_item: [*c]listitem_T, + lw_next: [*c]listwatch_T, +}; +pub const listwatch_T = struct_listwatch_S; +pub const list_T = struct_listvar_S; +pub const struct_listvar_S = extern struct { + lv_first: [*c]listitem_T, + lv_last: [*c]listitem_T, + lv_watch: [*c]listwatch_T, + lv_idx_item: [*c]listitem_T, + lv_copylist: [*c]list_T, + lv_used_next: [*c]list_T, + lv_used_prev: [*c]list_T, + lv_refcount: c_int, + lv_len: c_int, + lv_idx: c_int, + lv_copyID: c_int, + lv_lock: VarLockStatus, + lua_table_ref: LuaRef, +}; +const struct_unnamed_46 = extern struct { + di_tv: typval_T, + di_flags: u8, + di_key: [21]u8, +}; +pub const struct_funccall_S = extern struct { + fc_func: [*c]ufunc_T, + fc_linenr: c_int, + fc_returned: c_int, + fc_fixvar: [12]struct_unnamed_46, + fc_l_vars: dict_T, + fc_l_vars_var: ScopeDictDictItem, + fc_l_avars: dict_T, + fc_l_avars_var: ScopeDictDictItem, + fc_l_varlist: list_T, + fc_l_listitems: [20]listitem_T, + fc_rettv: [*c]typval_T, + fc_breakpoint: linenr_T, + fc_dbg_tick: c_int, + fc_level: c_int, + fc_defer: garray_T, + fc_prof_child: proftime_T, + fc_caller: [*c]funccall_T, + fc_refcount: c_int, + fc_copyID: c_int, + fc_ufuncs: garray_T, +}; +pub const funccall_T = struct_funccall_S; +pub const struct_ufunc = extern struct { + uf_varargs: c_int align(8), + uf_flags: c_int, + uf_calls: c_int, + uf_cleared: bool, + uf_args: garray_T, + uf_def_args: garray_T, + uf_lines: garray_T, + uf_profiling: c_int, + uf_prof_initialized: c_int, + uf_luaref: LuaRef, + uf_tm_count: c_int, + uf_tm_total: proftime_T, + uf_tm_self: proftime_T, + uf_tm_children: proftime_T, + uf_tml_count: [*c]c_int, + uf_tml_total: [*c]proftime_T, + uf_tml_self: [*c]proftime_T, + uf_tml_start: proftime_T, + uf_tml_children: proftime_T, + uf_tml_wait: proftime_T, + uf_tml_idx: c_int, + uf_tml_execed: c_int, + uf_script_ctx: sctx_T, + uf_refcount: c_int, + uf_scoped: [*c]funccall_T, + uf_name_exp: [*c]u8, + pub fn uf_name(self: anytype) @import("std").zig.c_translation.FlexibleArrayType(@TypeOf(self), u8) { + const Intermediate = @import("std").zig.c_translation.FlexibleArrayType(@TypeOf(self), u8); + const ReturnType = @import("std").zig.c_translation.FlexibleArrayType(@TypeOf(self), u8); + return @ptrCast(ReturnType, @alignCast(@alignOf(u8), @ptrCast(Intermediate, self) + 216)); + } +}; +pub const ufunc_T = struct_ufunc; +pub const struct_partial_S = extern struct { + pt_refcount: c_int, + pt_name: [*c]u8, + pt_func: [*c]ufunc_T, + pt_auto: bool, + pt_argc: c_int, + pt_argv: [*c]typval_T, + pt_dict: [*c]dict_T, +}; +pub const partial_T = struct_partial_S; +pub const struct_blobvar_S = extern struct { + bv_ga: garray_T, + bv_refcount: c_int, + bv_lock: VarLockStatus, +}; +pub const blob_T = struct_blobvar_S; +pub const kCallbackNone: c_int = 0; +pub const kCallbackFuncref: c_int = 1; +pub const kCallbackPartial: c_int = 2; +pub const kCallbackLua: c_int = 3; +pub const CallbackType = c_uint; +const union_unnamed_47 = extern union { + funcref: [*c]u8, + partial: [*c]partial_T, + luaref: LuaRef, +}; +pub const Callback = extern struct { + data: union_unnamed_47, + type: CallbackType, +}; +pub const struct_dict_watcher = extern struct { + callback: Callback, + key_pattern: [*c]u8, + key_pattern_len: usize, + node: QUEUE, + busy: bool, + needs_free: bool, +}; +pub const DictWatcher = struct_dict_watcher; +pub const kBoolVarFalse: c_int = 0; +pub const kBoolVarTrue: c_int = 1; +pub const BoolVarValue = c_uint; +pub const kSpecialVarNull: c_int = 0; +pub const SpecialVarValue = c_uint; +pub const VAR_UNLOCKED: c_int = 0; +pub const VAR_LOCKED: c_int = 1; +pub const VAR_FIXED: c_int = 2; +pub const VarLockStatus = c_uint; +pub const VAR_UNKNOWN: c_int = 0; +pub const VAR_NUMBER: c_int = 1; +pub const VAR_STRING: c_int = 2; +pub const VAR_FUNC: c_int = 3; +pub const VAR_LIST: c_int = 4; +pub const VAR_DICT: c_int = 5; +pub const VAR_FLOAT: c_int = 6; +pub const VAR_BOOL: c_int = 7; +pub const VAR_SPECIAL: c_int = 8; +pub const VAR_PARTIAL: c_int = 9; +pub const VAR_BLOB: c_int = 10; +pub const VarType = c_uint; +pub const union_typval_vval_union = extern union { + v_number: varnumber_T, + v_bool: BoolVarValue, + v_special: SpecialVarValue, + v_float: float_T, + v_string: [*c]u8, + v_list: [*c]list_T, + v_dict: [*c]dict_T, + v_partial: [*c]partial_T, + v_blob: [*c]blob_T, +}; +pub const typval_T = extern struct { + v_type: VarType, + v_lock: VarLockStatus, + vval: union_typval_vval_union, +}; +pub const VAR_NO_SCOPE: c_int = 0; +pub const VAR_SCOPE: c_int = 1; +pub const VAR_DEF_SCOPE: c_int = 2; +pub const ScopeType = c_uint; +pub const staticList10_T = extern struct { + sl_list: list_T, + sl_items: [10]listitem_T, +}; +pub const ScopeDictDictItem = extern struct { + di_tv: typval_T, + di_flags: u8, + di_key: [1]u8, +}; +pub const dictitem_T = extern struct { + di_tv: typval_T align(8), + di_flags: u8, + pub fn di_key(self: anytype) @import("std").zig.c_translation.FlexibleArrayType(@TypeOf(self), u8) { + const Intermediate = @import("std").zig.c_translation.FlexibleArrayType(@TypeOf(self), u8); + const ReturnType = @import("std").zig.c_translation.FlexibleArrayType(@TypeOf(self), u8); + return @ptrCast(ReturnType, @alignCast(@alignOf(u8), @ptrCast(Intermediate, self) + 17)); + } +}; +pub const DI_FLAGS_RO: c_int = 1; +pub const DI_FLAGS_RO_SBX: c_int = 2; +pub const DI_FLAGS_FIX: c_int = 4; +pub const DI_FLAGS_LOCK: c_int = 8; +pub const DI_FLAGS_ALLOC: c_int = 16; +pub const DictItemFlags = c_uint; +pub const scid_T = c_int; +pub const sctx_T = extern struct { + sc_sid: scid_T, + sc_seq: c_int, + sc_lnum: linenr_T, +}; +pub const MAX_FUNC_ARGS: c_int = 20; +const enum_unnamed_48 = c_uint; +pub const VAR_SHORT_LEN: c_int = 20; +const enum_unnamed_49 = c_uint; +pub const FIXVAR_CNT: c_int = 12; +const enum_unnamed_50 = c_uint; +pub const struct_ht_stack_S = extern struct { + ht: [*c]hashtab_T, + prev: [*c]struct_ht_stack_S, +}; +pub const ht_stack_T = struct_ht_stack_S; +pub const struct_list_stack_S = extern struct { + list: [*c]list_T, + prev: [*c]struct_list_stack_S, +}; +pub const list_stack_T = struct_list_stack_S; +pub const ListSortItem = extern struct { + item: [*c]listitem_T, + idx: c_int, +}; +pub const ListSorter = ?*const fn (?*const anyopaque, ?*const anyopaque) callconv(.C) c_int; +pub extern fn gettext(__msgid: [*c]const u8) [*c]u8; +pub extern fn dgettext(__domainname: [*c]const u8, __msgid: [*c]const u8) [*c]u8; +pub extern fn __dgettext(__domainname: [*c]const u8, __msgid: [*c]const u8) [*c]u8; +pub extern fn dcgettext(__domainname: [*c]const u8, __msgid: [*c]const u8, __category: c_int) [*c]u8; +pub extern fn __dcgettext(__domainname: [*c]const u8, __msgid: [*c]const u8, __category: c_int) [*c]u8; +pub extern fn ngettext(__msgid1: [*c]const u8, __msgid2: [*c]const u8, __n: c_ulong) [*c]u8; +pub extern fn dngettext(__domainname: [*c]const u8, __msgid1: [*c]const u8, __msgid2: [*c]const u8, __n: c_ulong) [*c]u8; +pub extern fn dcngettext(__domainname: [*c]const u8, __msgid1: [*c]const u8, __msgid2: [*c]const u8, __n: c_ulong, __category: c_int) [*c]u8; +pub extern fn textdomain(__domainname: [*c]const u8) [*c]u8; +pub extern fn bindtextdomain(__domainname: [*c]const u8, __dirname: [*c]const u8) [*c]u8; +pub extern fn bind_textdomain_codeset(__domainname: [*c]const u8, __codeset: [*c]const u8) [*c]u8; +pub extern fn __errno_location() [*c]c_int; +pub const iconv_t = ?*anyopaque; +pub extern fn iconv_close(__cd: iconv_t) c_int; +pub extern fn iconv_open(__tocode: [*c]const u8, __fromcode: [*c]const u8) iconv_t; +pub extern fn iconv(__cd: iconv_t, noalias __inbuf: [*c][*c]u8, noalias __inbytesleft: [*c]usize, noalias __outbuf: [*c][*c]u8, noalias __outbytesleft: [*c]usize) usize; +pub const MB_MAXCHAR: c_int = 6; +const enum_unnamed_51 = c_uint; +pub const ENC_8BIT: c_int = 1; +pub const ENC_DBCS: c_int = 2; +pub const ENC_UNICODE: c_int = 4; +pub const ENC_ENDIAN_B: c_int = 16; +pub const ENC_ENDIAN_L: c_int = 32; +pub const ENC_2BYTE: c_int = 64; +pub const ENC_4BYTE: c_int = 128; +pub const ENC_2WORD: c_int = 256; +pub const ENC_LATIN1: c_int = 512; +pub const ENC_LATIN9: c_int = 1024; +pub const ENC_MACROMAN: c_int = 2048; +const enum_unnamed_52 = c_uint; +pub const CONV_NONE: c_int = 0; +pub const CONV_TO_UTF8: c_int = 1; +pub const CONV_9_TO_UTF8: c_int = 2; +pub const CONV_TO_LATIN1: c_int = 3; +pub const CONV_TO_LATIN9: c_int = 4; +pub const CONV_ICONV: c_int = 5; +pub const ConvFlags = c_uint; +pub const vimconv_T = extern struct { + vc_type: c_int, + vc_factor: c_int, + vc_fd: iconv_t, + vc_fail: bool, +}; +pub const kZIndexDefaultGrid: c_int = 0; +pub const kZIndexFloatDefault: c_int = 50; +pub const kZIndexPopupMenu: c_int = 100; +pub const kZIndexMessages: c_int = 200; +pub const kZIndexCmdlinePopupMenu: c_int = 250; +const enum_unnamed_53 = c_uint; +pub const GridLineEvent = extern struct { + args: [3]c_int, + icell: c_int, + ncells: c_int, + coloff: c_int, + cur_attr: c_int, + clear_width: c_int, +}; +pub const HlMessageChunk = extern struct { + text: String, + attr: c_int, +}; +pub const HlMessage = extern struct { + size: usize, + capacity: usize, + items: [*c]HlMessageChunk, +}; +pub const struct_msg_hist = extern struct { + next: [*c]struct_msg_hist, + msg: [*c]u8, + kind: [*c]const u8, + attr: c_int, + multiline: bool, + multiattr: HlMessage, +}; +pub const MessageHistoryEntry = struct_msg_hist; +pub extern var first_msg_hist: [*c]MessageHistoryEntry; +pub extern var last_msg_hist: [*c]MessageHistoryEntry; +pub extern var msg_ext_need_clear: bool; +pub extern var msg_grid: ScreenGrid; +pub extern var msg_grid_pos: c_int; +pub extern var msg_grid_adj: ScreenGrid; +pub extern var msg_scrolled_at_flush: c_int; +pub extern var msg_grid_scroll_discount: c_int; +pub extern fn msg_grid_set_pos(row: c_int, scrolled: bool) void; +pub extern fn msg_use_grid() bool; +pub extern fn msg_grid_validate() void; +pub extern fn msg(s: [*c]const u8) c_int; +pub extern fn verb_msg(s: [*c]const u8) c_int; +pub extern fn msg_attr(s: [*c]const u8, attr: c_int) c_int; +pub extern fn msg_multiline_attr(s: [*c]const u8, attr: c_int, check_int: bool, need_clear: [*c]bool) void; +pub extern fn msg_multiattr(hl_msg: HlMessage, kind: [*c]const u8, history: bool) void; +pub extern fn msg_attr_keep(s: [*c]const u8, attr: c_int, keep: bool, multiline: bool) bool; +pub extern fn msg_strtrunc(s: [*c]const u8, force: c_int) [*c]u8; +pub extern fn trunc_string(s: [*c]const u8, buf: [*c]u8, room_in: c_int, buflen: c_int) void; +pub extern fn smsg(s: [*c]const u8, ...) c_int; +pub extern fn smsg_attr(attr: c_int, s: [*c]const u8, ...) c_int; +pub extern fn smsg_attr_keep(attr: c_int, s: [*c]const u8, ...) c_int; +pub extern fn reset_last_sourcing() void; +pub extern fn msg_source(attr: c_int) void; +pub extern fn emsg_not_now() c_int; +pub extern fn emsg(s: [*c]const u8) bool; +pub extern fn emsg_invreg(name: c_int) void; +pub extern fn semsg(fmt: [*c]const u8, ...) bool; +pub extern fn semsg_multiline(fmt: [*c]const u8, ...) bool; +pub extern fn iemsg(s: [*c]const u8) void; +pub extern fn siemsg(s: [*c]const u8, ...) void; +pub extern fn internal_error(where: [*c]const u8) void; +pub extern fn msg_schedule_semsg(fmt: [*c]const u8, ...) void; +pub extern fn msg_trunc_attr(s: [*c]u8, force: bool, attr: c_int) [*c]u8; +pub extern fn msg_may_trunc(force: bool, s: [*c]u8) [*c]u8; +pub extern fn hl_msg_free(hl_msg: HlMessage) void; +pub extern fn delete_first_msg() c_int; +pub extern fn ex_messages(eap_p: ?*anyopaque) void; +pub extern fn msg_end_prompt() void; +pub extern fn wait_return(redraw: c_int) void; +pub extern fn set_keep_msg(s: [*c]const u8, attr: c_int) void; +pub extern fn messaging() bool; +pub extern fn msgmore(n: c_long) void; +pub extern fn msg_ext_set_kind(msg_kind: [*c]const u8) void; +pub extern fn msg_start() void; +pub extern fn msg_starthere() void; +pub extern fn msg_putchar(c: c_int) void; +pub extern fn msg_putchar_attr(c: c_int, attr: c_int) void; +pub extern fn msg_outnum(n: c_long) void; +pub extern fn msg_home_replace(fname: [*c]const u8) void; +pub extern fn msg_home_replace_hl(fname: [*c]const u8) void; +pub extern fn msg_outtrans(str: [*c]const u8) c_int; +pub extern fn msg_outtrans_attr(str: [*c]const u8, attr: c_int) c_int; +pub extern fn msg_outtrans_len(str: [*c]const u8, len: c_int) c_int; +pub extern fn msg_outtrans_one(p: [*c]const u8, attr: c_int) [*c]const u8; +pub extern fn msg_outtrans_len_attr(msgstr: [*c]const u8, len: c_int, attr: c_int) c_int; +pub extern fn msg_make(arg: [*c]const u8) void; +pub extern fn msg_outtrans_special(strstart: [*c]const u8, from: bool, maxlen: c_int) c_int; +pub extern fn str2special_save(str: [*c]const u8, replace_spaces: bool, replace_lt: bool) [*c]u8; +pub extern fn str2special(sp: [*c][*c]const u8, replace_spaces: bool, replace_lt: bool) [*c]const u8; +pub extern fn str2specialbuf(sp: [*c]const u8, buf: [*c]u8, len: usize) void; +pub extern fn msg_prt_line(s: [*c]const u8, list: c_int) void; +pub extern fn msg_puts(s: [*c]const u8) void; +pub extern fn msg_puts_title(s: [*c]const u8) void; +pub extern fn msg_outtrans_long_attr(longstr: [*c]const u8, attr: c_int) void; +pub extern fn msg_outtrans_long_len_attr(longstr: [*c]const u8, len: c_int, attr: c_int) void; +pub extern fn msg_puts_attr(s: [*c]const u8, attr: c_int) void; +pub extern fn msg_puts_attr_len(str: [*c]const u8, len: ptrdiff_t, attr: c_int) void; +pub extern fn msg_printf_attr(attr: c_int, fmt: [*c]const u8, ...) void; +pub extern fn message_filtered(msg: [*c]const u8) bool; +pub extern fn msg_scrollsize() c_int; +pub extern fn msg_do_throttle() bool; +pub extern fn msg_scroll_up(may_throttle: bool, zerocmd: bool) void; +pub extern fn msg_scroll_flush() void; +pub extern fn msg_reset_scroll() void; +pub extern fn may_clear_sb_text() void; +pub extern fn sb_text_start_cmdline() void; +pub extern fn sb_text_restart_cmdline() void; +pub extern fn sb_text_end_cmdline() void; +pub extern fn clear_sb_text(all: c_int) void; +pub extern fn show_sb_text() void; +pub extern fn msg_sb_eol() void; +pub extern fn msg_use_printf() c_int; +pub extern fn msg_moremsg(full: c_int) void; +pub extern fn repeat_message() void; +pub extern fn msg_clr_eos() void; +pub extern fn msg_clr_eos_force() void; +pub extern fn msg_clr_cmdline() void; +pub extern fn msg_end() c_int; +pub extern fn msg_ext_ui_flush() void; +pub extern fn msg_ext_flush_showmode() void; +pub extern fn msg_ext_clear(force: bool) void; +pub extern fn msg_ext_clear_later() void; +pub extern fn msg_ext_check_clear() void; +pub extern fn msg_ext_is_visible() bool; +pub extern fn msg_check() void; +pub extern fn redirecting() c_int; +pub extern fn verbose_enter() void; +pub extern fn verbose_leave() void; +pub extern fn verbose_enter_scroll() void; +pub extern fn verbose_leave_scroll() void; +pub extern fn verbose_stop() void; +pub extern fn verbose_open() c_int; +pub extern fn give_warning(message: [*c]const u8, hl: bool) void; +pub extern fn give_warning2(message: [*c]const u8, a1: [*c]const u8, hl: bool) void; +pub extern fn msg_advance(col: c_int) void; +pub extern fn do_dialog(@"type": c_int, title: [*c]u8, message: [*c]u8, buttons: [*c]u8, dfltbutton: c_int, textfield: [*c]u8, ex_cmd: c_int) c_int; +pub extern fn display_confirm_msg() void; +pub extern fn vim_dialog_yesno(@"type": c_int, title: [*c]u8, message: [*c]u8, dflt: c_int) c_int; +pub extern fn vim_dialog_yesnocancel(@"type": c_int, title: [*c]u8, message: [*c]u8, dflt: c_int) c_int; +pub extern fn vim_dialog_yesnoallcancel(@"type": c_int, title: [*c]u8, message: [*c]u8, dflt: c_int) c_int; +pub extern fn msg_check_for_delay(check_msg_scroll: bool) void; +pub inline fn tv_list_ref(l: [*c]list_T) void { + if (l == @ptrCast([*c]list_T, @alignCast(@import("std").meta.alignment([*c]list_T), @intToPtr(?*anyopaque, @as(c_int, 0))))) { + return; + } + l.*.lv_refcount += 1; +} +pub inline fn tv_list_set_ret(tv: [*c]typval_T, l: [*c]list_T) void { + tv.*.v_type = @bitCast(c_uint, VAR_LIST); + tv.*.vval.v_list = l; + tv_list_ref(l); +} +pub fn tv_list_locked(l: [*c]const list_T) callconv(.C) VarLockStatus { + if (l == @ptrCast([*c]const list_T, @alignCast(@import("std").meta.alignment([*c]const list_T), @intToPtr(?*anyopaque, @as(c_int, 0))))) { + return @bitCast(c_uint, VAR_FIXED); + } + return l.*.lv_lock; +} +pub fn tv_list_set_lock(l: [*c]list_T, lock: VarLockStatus) callconv(.C) void { + if (l == @ptrCast([*c]list_T, @alignCast(@import("std").meta.alignment([*c]list_T), @intToPtr(?*anyopaque, @as(c_int, 0))))) { + _ = blk: { + _ = @sizeOf(c_int); + break :blk blk_1: { + break :blk_1 if (lock == @bitCast(c_uint, VAR_FIXED)) {} else { + __assert_fail("lock == VAR_FIXED", "_nvim/src/nvim/eval/typval.h", @bitCast(c_uint, @as(c_int, 151)), "void tv_list_set_lock(list_T *const, const VarLockStatus)"); + }; + }; + }; + return; + } + l.*.lv_lock = lock; +} +pub fn tv_list_set_copyid(l: [*c]list_T, copyid: c_int) callconv(.C) void { + l.*.lv_copyID = copyid; +} +pub fn tv_list_len(l: [*c]const list_T) callconv(.C) c_int { + if (l == @ptrCast([*c]const list_T, @alignCast(@import("std").meta.alignment([*c]const list_T), @intToPtr(?*anyopaque, @as(c_int, 0))))) { + return 0; + } + return l.*.lv_len; +} +pub fn tv_list_copyid(l: [*c]const list_T) callconv(.C) c_int { + return l.*.lv_copyID; +} +pub fn tv_list_latest_copy(l: [*c]const list_T) callconv(.C) [*c]list_T { + return l.*.lv_copylist; +} +pub fn tv_list_uidx(l: [*c]const list_T, arg_n: c_int) callconv(.C) c_int { + var n = arg_n; + if (n < @as(c_int, 0)) { + n += tv_list_len(l); + } + if ((n < @as(c_int, 0)) or (n >= tv_list_len(l))) { + return -@as(c_int, 1); + } + return n; +} +pub fn tv_list_has_watchers(l: [*c]const list_T) callconv(.C) bool { + return (l != null) and (l.*.lv_watch != null); +} +pub fn tv_list_first(l: [*c]const list_T) callconv(.C) [*c]listitem_T { + if (l == @ptrCast([*c]const list_T, @alignCast(@import("std").meta.alignment([*c]const list_T), @intToPtr(?*anyopaque, @as(c_int, 0))))) { + return null; + } + return l.*.lv_first; +} +pub fn tv_list_last(l: [*c]const list_T) callconv(.C) [*c]listitem_T { + if (l == @ptrCast([*c]const list_T, @alignCast(@import("std").meta.alignment([*c]const list_T), @intToPtr(?*anyopaque, @as(c_int, 0))))) { + return null; + } + return l.*.lv_last; +} +pub inline fn tv_dict_set_ret(tv: [*c]typval_T, d: [*c]dict_T) void { + tv.*.v_type = @bitCast(c_uint, VAR_DICT); + tv.*.vval.v_dict = d; + if (d != @ptrCast([*c]dict_T, @alignCast(@import("std").meta.alignment([*c]dict_T), @intToPtr(?*anyopaque, @as(c_int, 0))))) { + d.*.dv_refcount += 1; + } +} +pub fn tv_dict_len(d: [*c]const dict_T) callconv(.C) c_long { + if (d == @ptrCast([*c]const dict_T, @alignCast(@import("std").meta.alignment([*c]const dict_T), @intToPtr(?*anyopaque, @as(c_int, 0))))) { + return 0; + } + return @bitCast(c_long, d.*.dv_hashtab.ht_used); +} +pub fn tv_dict_is_watched(d: [*c]const dict_T) callconv(.C) bool { + return (d != null) and !(QUEUE_EMPTY(&d.*.watchers) != 0); +} +pub inline fn tv_blob_set_ret(tv: [*c]typval_T, b: [*c]blob_T) void { + tv.*.v_type = @bitCast(c_uint, VAR_BLOB); + tv.*.vval.v_blob = b; + if (b != @ptrCast([*c]blob_T, @alignCast(@import("std").meta.alignment([*c]blob_T), @intToPtr(?*anyopaque, @as(c_int, 0))))) { + b.*.bv_refcount += 1; + } +} +pub fn tv_blob_len(b: [*c]const blob_T) callconv(.C) c_int { + if (b == @ptrCast([*c]const blob_T, @alignCast(@import("std").meta.alignment([*c]const blob_T), @intToPtr(?*anyopaque, @as(c_int, 0))))) { + return 0; + } + return b.*.bv_ga.ga_len; +} +pub inline fn tv_blob_get(b: [*c]const blob_T, arg_idx: c_int) u8 { + var idx = arg_idx; + return (blk: { + const tmp = idx; + if (tmp >= 0) break :blk @ptrCast([*c]u8, @alignCast(@import("std").meta.alignment([*c]u8), b.*.bv_ga.ga_data)) + @intCast(usize, tmp) else break :blk @ptrCast([*c]u8, @alignCast(@import("std").meta.alignment([*c]u8), b.*.bv_ga.ga_data)) - ~@bitCast(usize, @intCast(isize, tmp) +% -1); + }).*; +} +pub inline fn tv_blob_set(blob: [*c]blob_T, arg_idx: c_int, arg_c: u8) void { + var idx = arg_idx; + var c = arg_c; + (blk: { + const tmp = idx; + if (tmp >= 0) break :blk @ptrCast([*c]u8, @alignCast(@import("std").meta.alignment([*c]u8), blob.*.bv_ga.ga_data)) + @intCast(usize, tmp) else break :blk @ptrCast([*c]u8, @alignCast(@import("std").meta.alignment([*c]u8), blob.*.bv_ga.ga_data)) - ~@bitCast(usize, @intCast(isize, tmp) +% -1); + }).* = c; +} +pub fn tv_init(tv: [*c]typval_T) callconv(.C) void { + if (tv != @ptrCast([*c]typval_T, @alignCast(@import("std").meta.alignment([*c]typval_T), @intToPtr(?*anyopaque, @as(c_int, 0))))) { + _ = memset(@ptrCast(?*anyopaque, tv), @as(c_int, 0), @sizeOf(typval_T)); + } +} +pub extern const tv_empty_string: [*c]const u8; +pub extern var tv_in_free_unref_items: bool; +pub fn tv_get_float_chk(tv: [*c]const typval_T, ret_f: [*c]float_T) callconv(.C) bool { + if (tv.*.v_type == @bitCast(c_uint, VAR_FLOAT)) { + ret_f.* = tv.*.vval.v_float; + return @as(c_int, 1) != 0; + } + if (tv.*.v_type == @bitCast(c_uint, VAR_NUMBER)) { + ret_f.* = @intToFloat(float_T, tv.*.vval.v_number); + return @as(c_int, 1) != 0; + } + _ = semsg("%s", gettext("E808: Number or Float required")); + return @as(c_int, 0) != 0; +} +pub inline fn tv_dict_watcher_node_data(arg_q: [*c]QUEUE) [*c]DictWatcher { + var q = arg_q; + return @ptrCast([*c]DictWatcher, @alignCast(@import("std").meta.alignment([*c]DictWatcher), @ptrCast([*c]u8, @alignCast(@import("std").meta.alignment([*c]u8), q)) - @offsetOf(struct_dict_watcher, "node"))); +} +pub fn tv_is_func(tv: typval_T) callconv(.C) bool { + return (tv.v_type == @bitCast(c_uint, VAR_FUNC)) or (tv.v_type == @bitCast(c_uint, VAR_PARTIAL)); +} +pub extern fn tv_list_item_remove(l: [*c]list_T, item: [*c]listitem_T) [*c]listitem_T; +pub extern fn tv_list_watch_add(l: [*c]list_T, lw: [*c]listwatch_T) void; +pub extern fn tv_list_watch_remove(l: [*c]list_T, lwrem: [*c]listwatch_T) void; +pub extern fn tv_list_watch_fix(l: [*c]list_T, item: [*c]const listitem_T) void; +pub extern fn tv_list_alloc(len: ptrdiff_t) [*c]list_T; +pub extern fn tv_list_init_static10(sl: [*c]staticList10_T) void; +pub extern fn tv_list_init_static(l: [*c]list_T) void; +pub extern fn tv_list_free_contents(l: [*c]list_T) void; +pub extern fn tv_list_free_list(l: [*c]list_T) void; +pub extern fn tv_list_free(l: [*c]list_T) void; +pub extern fn tv_list_unref(l: [*c]list_T) void; +pub extern fn tv_list_drop_items(l: [*c]list_T, item: [*c]listitem_T, item2: [*c]listitem_T) void; +pub extern fn tv_list_remove_items(l: [*c]list_T, item: [*c]listitem_T, item2: [*c]listitem_T) void; +pub extern fn tv_list_move_items(l: [*c]list_T, item: [*c]listitem_T, item2: [*c]listitem_T, tgt_l: [*c]list_T, cnt: c_int) void; +pub extern fn tv_list_insert(l: [*c]list_T, ni: [*c]listitem_T, item: [*c]listitem_T) void; +pub extern fn tv_list_insert_tv(l: [*c]list_T, tv: [*c]typval_T, item: [*c]listitem_T) void; +pub extern fn tv_list_append(l: [*c]list_T, item: [*c]listitem_T) void; +pub extern fn tv_list_append_tv(l: [*c]list_T, tv: [*c]typval_T) void; +pub extern fn tv_list_append_owned_tv(l: [*c]list_T, tv: typval_T) void; +pub extern fn tv_list_append_list(l: [*c]list_T, itemlist: [*c]list_T) void; +pub extern fn tv_list_append_dict(l: [*c]list_T, dict: [*c]dict_T) void; +pub extern fn tv_list_append_string(l: [*c]list_T, str: [*c]const u8, len: isize) void; +pub extern fn tv_list_append_allocated_string(l: [*c]list_T, str: [*c]u8) void; +pub extern fn tv_list_append_number(l: [*c]list_T, n: varnumber_T) void; +pub extern fn tv_list_copy(conv: [*c]const vimconv_T, orig: [*c]list_T, deep: bool, copyID: c_int) [*c]list_T; +pub extern fn tv_list_flatten(list: [*c]list_T, first: [*c]listitem_T, maxitems: c_long, maxdepth: c_long) void; +pub extern fn tv_list_extend(l1: [*c]list_T, l2: [*c]list_T, bef: [*c]listitem_T) void; +pub extern fn tv_list_concat(l1: [*c]list_T, l2: [*c]list_T, tv: [*c]typval_T) c_int; +pub extern fn tv_list_join(gap: [*c]garray_T, l: [*c]list_T, sep: [*c]const u8) c_int; +pub extern fn f_join(argvars: [*c]typval_T, rettv: [*c]typval_T, fptr: EvalFuncData) void; +pub extern fn f_list2str(argvars: [*c]typval_T, rettv: [*c]typval_T, fptr: EvalFuncData) void; +pub extern fn tv_list_remove(argvars: [*c]typval_T, rettv: [*c]typval_T, arg_errmsg: [*c]const u8) void; +pub extern fn f_sort(argvars: [*c]typval_T, rettv: [*c]typval_T, fptr: EvalFuncData) void; +pub extern fn f_uniq(argvars: [*c]typval_T, rettv: [*c]typval_T, fptr: EvalFuncData) void; +pub extern fn tv_list_equal(l1: [*c]list_T, l2: [*c]list_T, ic: bool, recursive: bool) bool; +pub extern fn tv_list_reverse(l: [*c]list_T) void; +pub extern fn tv_list_item_sort(l: [*c]list_T, ptrs: [*c]ListSortItem, item_compare_func: ListSorter, errp: [*c]const bool) void; +pub extern fn tv_list_find(l: [*c]list_T, n: c_int) [*c]listitem_T; +pub extern fn tv_list_find_nr(l: [*c]list_T, n: c_int, ret_error: [*c]bool) varnumber_T; +pub extern fn tv_list_find_str(l: [*c]list_T, n: c_int) [*c]const u8; +pub extern fn tv_list_idx_of_item(l: [*c]const list_T, item: [*c]const listitem_T) c_long; +pub extern fn tv_dict_watcher_add(dict: [*c]dict_T, key_pattern: [*c]const u8, key_pattern_len: usize, callback: Callback) void; +pub extern fn tv_callback_equal(cb1: [*c]const Callback, cb2: [*c]const Callback) bool; +pub extern fn callback_free(callback: [*c]Callback) void; +pub extern fn callback_put(cb: [*c]Callback, tv: [*c]typval_T) void; +pub extern fn callback_copy(dest: [*c]Callback, src: [*c]Callback) void; +pub extern fn callback_to_string(cb: [*c]Callback) [*c]u8; +pub extern fn tv_dict_watcher_remove(dict: [*c]dict_T, key_pattern: [*c]const u8, key_pattern_len: usize, callback: Callback) bool; +pub extern fn tv_dict_watcher_notify(dict: [*c]dict_T, key: [*c]const u8, newtv: [*c]typval_T, oldtv: [*c]typval_T) void; +pub extern fn tv_dict_item_alloc_len(key: [*c]const u8, key_len: usize) [*c]dictitem_T; +pub extern fn tv_dict_item_alloc(key: [*c]const u8) [*c]dictitem_T; +pub extern fn tv_dict_item_free(item: [*c]dictitem_T) void; +pub extern fn tv_dict_item_copy(di: [*c]dictitem_T) [*c]dictitem_T; +pub extern fn tv_dict_item_remove(dict: [*c]dict_T, item: [*c]dictitem_T) void; +pub extern fn tv_dict_alloc() [*c]dict_T; +pub extern fn tv_dict_free_contents(d: [*c]dict_T) void; +pub extern fn tv_dict_free_dict(d: [*c]dict_T) void; +pub extern fn tv_dict_free(d: [*c]dict_T) void; +pub extern fn tv_dict_unref(d: [*c]dict_T) void; +pub extern fn tv_dict_find(d: [*c]const dict_T, key: [*c]const u8, len: ptrdiff_t) [*c]dictitem_T; +pub extern fn tv_dict_get_tv(d: [*c]dict_T, key: [*c]const u8, rettv: [*c]typval_T) c_int; +pub extern fn tv_dict_get_number(d: [*c]const dict_T, key: [*c]const u8) varnumber_T; +pub extern fn tv_dict_get_number_def(d: [*c]const dict_T, key: [*c]const u8, def: c_int) varnumber_T; +pub extern fn tv_dict_to_env(denv: [*c]dict_T) [*c][*c]u8; +pub extern fn tv_dict_get_string(d: [*c]const dict_T, key: [*c]const u8, save: bool) [*c]u8; +pub extern fn tv_dict_get_string_buf(d: [*c]const dict_T, key: [*c]const u8, numbuf: [*c]u8) [*c]const u8; +pub extern fn tv_dict_get_string_buf_chk(d: [*c]const dict_T, key: [*c]const u8, key_len: ptrdiff_t, numbuf: [*c]u8, def: [*c]const u8) [*c]const u8; +pub extern fn tv_dict_get_callback(d: [*c]dict_T, key: [*c]const u8, key_len: ptrdiff_t, result: [*c]Callback) bool; +pub extern fn tv_dict_wrong_func_name(d: [*c]dict_T, tv: [*c]typval_T, name: [*c]const u8) c_int; +pub extern fn tv_dict_add(d: [*c]dict_T, item: [*c]dictitem_T) c_int; +pub extern fn tv_dict_add_list(d: [*c]dict_T, key: [*c]const u8, key_len: usize, list: [*c]list_T) c_int; +pub extern fn tv_dict_add_tv(d: [*c]dict_T, key: [*c]const u8, key_len: usize, tv: [*c]typval_T) c_int; +pub extern fn tv_dict_add_dict(d: [*c]dict_T, key: [*c]const u8, key_len: usize, dict: [*c]dict_T) c_int; +pub extern fn tv_dict_add_nr(d: [*c]dict_T, key: [*c]const u8, key_len: usize, nr: varnumber_T) c_int; +pub extern fn tv_dict_add_float(d: [*c]dict_T, key: [*c]const u8, key_len: usize, nr: float_T) c_int; +pub extern fn tv_dict_add_bool(d: [*c]dict_T, key: [*c]const u8, key_len: usize, val: BoolVarValue) c_int; +pub extern fn tv_dict_add_str(d: [*c]dict_T, key: [*c]const u8, key_len: usize, val: [*c]const u8) c_int; +pub extern fn tv_dict_add_str_len(d: [*c]dict_T, key: [*c]const u8, key_len: usize, val: [*c]const u8, len: c_int) c_int; +pub extern fn tv_dict_add_allocated_str(d: [*c]dict_T, key: [*c]const u8, key_len: usize, val: [*c]u8) c_int; +pub extern fn tv_dict_clear(d: [*c]dict_T) void; +pub extern fn tv_dict_extend(d1: [*c]dict_T, d2: [*c]dict_T, action: [*c]const u8) void; +pub extern fn tv_dict_equal(d1: [*c]dict_T, d2: [*c]dict_T, ic: bool, recursive: bool) bool; +pub extern fn tv_dict_copy(conv: [*c]const vimconv_T, orig: [*c]dict_T, deep: bool, copyID: c_int) [*c]dict_T; +pub extern fn tv_dict_set_keys_readonly(dict: [*c]dict_T) void; +pub extern fn tv_blob_alloc() [*c]blob_T; +pub extern fn tv_blob_free(b: [*c]blob_T) void; +pub extern fn tv_blob_unref(b: [*c]blob_T) void; +pub extern fn tv_blob_equal(b1: [*c]const blob_T, b2: [*c]const blob_T) bool; +pub extern fn tv_blob_check_index(bloblen: c_int, n1: varnumber_T, quiet: bool) c_int; +pub extern fn tv_blob_check_range(bloblen: c_int, n1: varnumber_T, n2: varnumber_T, quiet: bool) c_int; +pub extern fn tv_blob_set_range(dest: [*c]blob_T, n1: c_int, n2: c_int, src: [*c]typval_T) c_int; +pub extern fn tv_blob_set_append(blob: [*c]blob_T, idx: c_int, byte: u8) void; +pub extern fn tv_blob_remove(argvars: [*c]typval_T, rettv: [*c]typval_T, arg_errmsg: [*c]const u8) void; +pub extern fn f_blob2list(argvars: [*c]typval_T, rettv: [*c]typval_T, fptr: EvalFuncData) void; +pub extern fn f_list2blob(argvars: [*c]typval_T, rettv: [*c]typval_T, fptr: EvalFuncData) void; +pub extern fn tv_list_alloc_ret(ret_tv: [*c]typval_T, len: ptrdiff_t) [*c]list_T; +pub extern fn tv_dict_alloc_lock(lock: VarLockStatus) [*c]dict_T; +pub extern fn tv_dict_alloc_ret(ret_tv: [*c]typval_T) void; +pub extern fn f_items(argvars: [*c]typval_T, rettv: [*c]typval_T, fptr: EvalFuncData) void; +pub extern fn f_keys(argvars: [*c]typval_T, rettv: [*c]typval_T, fptr: EvalFuncData) void; +pub extern fn f_values(argvars: [*c]typval_T, rettv: [*c]typval_T, fptr: EvalFuncData) void; +pub extern fn f_has_key(argvars: [*c]typval_T, rettv: [*c]typval_T, fptr: EvalFuncData) void; +pub extern fn tv_dict_remove(argvars: [*c]typval_T, rettv: [*c]typval_T, arg_errmsg: [*c]const u8) void; +pub extern fn tv_blob_alloc_ret(ret_tv: [*c]typval_T) void; +pub extern fn tv_blob_copy(from: [*c]typval_T, to: [*c]typval_T) void; +pub extern fn tv_clear(tv: [*c]typval_T) void; +pub extern fn tv_free(tv: [*c]typval_T) void; +pub extern fn tv_copy(from: [*c]const typval_T, to: [*c]typval_T) void; +pub extern fn tv_item_lock(tv: [*c]typval_T, deep: c_int, lock: bool, check_refcount: bool) void; +pub extern fn tv_islocked(tv: [*c]const typval_T) bool; +pub extern fn tv_check_lock(tv: [*c]const typval_T, name: [*c]const u8, name_len: usize) bool; +pub extern fn value_check_lock(lock: VarLockStatus, name: [*c]const u8, name_len: usize) bool; +pub extern fn tv_equal(tv1: [*c]typval_T, tv2: [*c]typval_T, ic: bool, recursive: bool) bool; +pub extern fn tv_check_str_or_nr(tv: [*c]const typval_T) bool; +pub extern fn tv_check_num(tv: [*c]const typval_T) bool; +pub extern fn tv_check_str(tv: [*c]const typval_T) bool; +pub extern fn tv_get_number(tv: [*c]const typval_T) varnumber_T; +pub extern fn tv_get_number_chk(tv: [*c]const typval_T, ret_error: [*c]bool) varnumber_T; +pub extern fn tv_get_lnum(tv: [*c]const typval_T) linenr_T; +pub extern fn tv_get_float(tv: [*c]const typval_T) float_T; +pub extern fn tv_check_for_string_arg(args: [*c]const typval_T, idx: c_int) c_int; +pub extern fn tv_check_for_nonempty_string_arg(args: [*c]const typval_T, idx: c_int) c_int; +pub extern fn tv_check_for_number_arg(args: [*c]const typval_T, idx: c_int) c_int; +pub extern fn tv_check_for_opt_number_arg(args: [*c]const typval_T, idx: c_int) c_int; +pub extern fn tv_check_for_blob_arg(args: [*c]const typval_T, idx: c_int) c_int; +pub extern fn tv_check_for_list_arg(args: [*c]const typval_T, idx: c_int) c_int; +pub extern fn tv_check_for_dict_arg(args: [*c]const typval_T, idx: c_int) c_int; +pub extern fn tv_check_for_opt_dict_arg(args: [*c]const typval_T, idx: c_int) c_int; +pub extern fn tv_check_for_string_or_list_arg(args: [*c]const typval_T, idx: c_int) c_int; +pub extern fn tv_check_for_string_or_func_arg(args: [*c]const typval_T, idx: c_int) c_int; +pub extern fn tv_check_for_list_or_blob_arg(args: [*c]const typval_T, idx: c_int) c_int; +pub extern fn tv_get_string_buf_chk(tv: [*c]const typval_T, buf: [*c]u8) [*c]const u8; +pub extern fn tv_get_string_chk(tv: [*c]const typval_T) [*c]const u8; +pub extern fn tv_get_string(tv: [*c]const typval_T) [*c]const u8; +pub extern fn tv_get_string_buf(tv: [*c]const typval_T, buf: [*c]u8) [*c]const u8; +pub extern fn tv2bool(tv: [*c]const typval_T) bool; +pub const RgbValue = i32; +pub const HL_INVERSE: c_int = 1; +pub const HL_BOLD: c_int = 2; +pub const HL_ITALIC: c_int = 4; +pub const HL_UNDERLINE_MASK: c_int = 56; +pub const HL_UNDERLINE: c_int = 8; +pub const HL_UNDERCURL: c_int = 16; +pub const HL_UNDERDOUBLE: c_int = 24; +pub const HL_UNDERDOTTED: c_int = 32; +pub const HL_UNDERDASHED: c_int = 40; +pub const HL_STANDOUT: c_int = 64; +pub const HL_STRIKETHROUGH: c_int = 128; +pub const HL_ALTFONT: c_int = 256; +pub const HL_NOCOMBINE: c_int = 1024; +pub const HL_BG_INDEXED: c_int = 2048; +pub const HL_FG_INDEXED: c_int = 4096; +pub const HL_DEFAULT: c_int = 8192; +pub const HL_GLOBAL: c_int = 16384; +pub const HlAttrFlags = c_uint; +pub const struct_attr_entry = extern struct { + rgb_ae_attr: i16, + cterm_ae_attr: i16, + rgb_fg_color: RgbValue, + rgb_bg_color: RgbValue, + rgb_sp_color: RgbValue, + cterm_fg_color: c_int, + cterm_bg_color: c_int, + hl_blend: c_int, +}; +pub const HlAttrs = struct_attr_entry; +pub const HLF_8: c_int = 0; +pub const HLF_EOB: c_int = 1; +pub const HLF_TERM: c_int = 2; +pub const HLF_TERMNC: c_int = 3; +pub const HLF_AT: c_int = 4; +pub const HLF_D: c_int = 5; +pub const HLF_E: c_int = 6; +pub const HLF_I: c_int = 7; +pub const HLF_L: c_int = 8; +pub const HLF_LC: c_int = 9; +pub const HLF_M: c_int = 10; +pub const HLF_CM: c_int = 11; +pub const HLF_N: c_int = 12; +pub const HLF_LNA: c_int = 13; +pub const HLF_LNB: c_int = 14; +pub const HLF_CLN: c_int = 15; +pub const HLF_CLS: c_int = 16; +pub const HLF_CLF: c_int = 17; +pub const HLF_R: c_int = 18; +pub const HLF_S: c_int = 19; +pub const HLF_SNC: c_int = 20; +pub const HLF_C: c_int = 21; +pub const HLF_VSP: c_int = 22; +pub const HLF_T: c_int = 23; +pub const HLF_V: c_int = 24; +pub const HLF_VNC: c_int = 25; +pub const HLF_W: c_int = 26; +pub const HLF_WM: c_int = 27; +pub const HLF_FL: c_int = 28; +pub const HLF_FC: c_int = 29; +pub const HLF_ADD: c_int = 30; +pub const HLF_CHD: c_int = 31; +pub const HLF_DED: c_int = 32; +pub const HLF_TXD: c_int = 33; +pub const HLF_SC: c_int = 34; +pub const HLF_CONCEAL: c_int = 35; +pub const HLF_SPB: c_int = 36; +pub const HLF_SPC: c_int = 37; +pub const HLF_SPR: c_int = 38; +pub const HLF_SPL: c_int = 39; +pub const HLF_PNI: c_int = 40; +pub const HLF_PSI: c_int = 41; +pub const HLF_PNK: c_int = 42; +pub const HLF_PSK: c_int = 43; +pub const HLF_PNX: c_int = 44; +pub const HLF_PSX: c_int = 45; +pub const HLF_PSB: c_int = 46; +pub const HLF_PST: c_int = 47; +pub const HLF_TP: c_int = 48; +pub const HLF_TPS: c_int = 49; +pub const HLF_TPF: c_int = 50; +pub const HLF_CUC: c_int = 51; +pub const HLF_CUL: c_int = 52; +pub const HLF_MC: c_int = 53; +pub const HLF_QFL: c_int = 54; +pub const HLF_0: c_int = 55; +pub const HLF_INACTIVE: c_int = 56; +pub const HLF_MSGSEP: c_int = 57; +pub const HLF_NFLOAT: c_int = 58; +pub const HLF_MSG: c_int = 59; +pub const HLF_BORDER: c_int = 60; +pub const HLF_WBR: c_int = 61; +pub const HLF_WBRNC: c_int = 62; +pub const HLF_CU: c_int = 63; +pub const HLF_BTITLE: c_int = 64; +pub const HLF_COUNT: c_int = 65; +pub const hlf_T = c_uint; +pub const hlf_names: [*c][*c]const u8 = @extern([*c][*c]const u8, .{ + .name = "hlf_names", +}); +pub extern var highlight_attr: [66]c_int; +pub extern var highlight_attr_last: [65]c_int; +pub extern var highlight_user: [9]c_int; +pub extern var highlight_stlnc: [9]c_int; +pub extern var cterm_normal_fg_color: c_int; +pub extern var cterm_normal_bg_color: c_int; +pub extern var normal_fg: RgbValue; +pub extern var normal_bg: RgbValue; +pub extern var normal_sp: RgbValue; +pub extern var ns_hl_global: NS; +pub extern var ns_hl_win: NS; +pub extern var ns_hl_fast: NS; +pub extern var ns_hl_active: NS; +pub extern var hl_attr_active: [*c]c_int; +pub const kHlUnknown: c_int = 0; +pub const kHlUI: c_int = 1; +pub const kHlSyntax: c_int = 2; +pub const kHlTerminal: c_int = 3; +pub const kHlCombine: c_int = 4; +pub const kHlBlend: c_int = 5; +pub const kHlBlendThrough: c_int = 6; +pub const HlKind = c_uint; +pub const HlEntry = extern struct { + attr: HlAttrs, + kind: HlKind, + id1: c_int, + id2: c_int, + winid: c_int, +}; +pub const ColorKey = extern struct { + ns_id: c_int, + syn_id: c_int, +}; +pub const ColorItem = extern struct { + attr_id: c_int, + link_id: c_int, + version: c_int, + is_default: bool, + link_global: bool, +}; +pub const HlPriId = extern struct { + hl_id: c_int, + priority: c_int, +}; +pub const khint32_t = c_uint; +pub const khint64_t = c_ulong; +pub const khint_t = khint32_t; +pub const khiter_t = khint_t; +pub fn __ac_X31_hash_string(arg_s: [*c]const u8) callconv(.C) khint_t { + var s = arg_s; + var h: khint_t = @bitCast(khint_t, @as(c_uint, s.*)); + if (h != 0) { + { + s += 1; + while (s.* != 0) : (s += 1) { + h = ((h << @intCast(@import("std").math.Log2Int(khint_t), 5)) -% h) +% @bitCast(khint_t, @as(c_uint, @bitCast(u8, s.*))); + } + } + } + return h; +} +pub fn __ac_Wang_hash(arg_key: khint_t) callconv(.C) khint_t { + var key = arg_key; + key +%= ~(key << @intCast(@import("std").math.Log2Int(khint_t), 15)); + key ^= key >> @intCast(@import("std").math.Log2Int(khint_t), 10); + key +%= key << @intCast(@import("std").math.Log2Int(khint_t), 3); + key ^= key >> @intCast(@import("std").math.Log2Int(khint_t), 6); + key +%= ~(key << @intCast(@import("std").math.Log2Int(khint_t), 11)); + key ^= key >> @intCast(@import("std").math.Log2Int(khint_t), 16); + return key; +} +pub const kh_cstr_t = [*c]const u8; +pub const VirtTextChunk = extern struct { + text: [*c]u8, + hl_id: c_int, +}; +pub const VirtText = extern struct { + size: usize, + capacity: usize, + items: [*c]VirtTextChunk, +}; +const union_unnamed_54 = extern union { + splice: ExtmarkSplice, + move: ExtmarkMove, + savepos: ExtmarkSavePos, +}; +pub const struct_undo_object = extern struct { + type: UndoObjectType, + data: union_unnamed_54, +}; +pub const ExtmarkUndoObject = struct_undo_object; +pub const extmark_undo_vec_t = extern struct { + size: usize, + capacity: usize, + items: [*c]ExtmarkUndoObject, +}; +pub const kExtmarkNOOP: c_int = 0; +pub const kExtmarkUndo: c_int = 1; +pub const kExtmarkNoUndo: c_int = 2; +pub const kExtmarkUndoNoRedo: c_int = 3; +pub const ExtmarkOp = c_uint; +pub const kDecorLevelNone: c_int = 0; +pub const kDecorLevelVisible: c_int = 1; +pub const kDecorLevelVirtLine: c_int = 2; +pub const DecorLevel = c_uint; +pub const cstr_t = [*c]const u8; +pub const ptr_t = ?*anyopaque; +pub const KITTY_KEY_ESCAPE: c_int = 57344; +pub const KITTY_KEY_ENTER: c_int = 57345; +pub const KITTY_KEY_TAB: c_int = 57346; +pub const KITTY_KEY_BACKSPACE: c_int = 57347; +pub const KITTY_KEY_INSERT: c_int = 57348; +pub const KITTY_KEY_DELETE: c_int = 57349; +pub const KITTY_KEY_LEFT: c_int = 57350; +pub const KITTY_KEY_RIGHT: c_int = 57351; +pub const KITTY_KEY_UP: c_int = 57352; +pub const KITTY_KEY_DOWN: c_int = 57353; +pub const KITTY_KEY_PAGE_UP: c_int = 57354; +pub const KITTY_KEY_PAGE_DOWN: c_int = 57355; +pub const KITTY_KEY_HOME: c_int = 57356; +pub const KITTY_KEY_END: c_int = 57357; +pub const KITTY_KEY_CAPS_LOCK: c_int = 57358; +pub const KITTY_KEY_SCROLL_LOCK: c_int = 57359; +pub const KITTY_KEY_NUM_LOCK: c_int = 57360; +pub const KITTY_KEY_PRINT_SCREEN: c_int = 57361; +pub const KITTY_KEY_PAUSE: c_int = 57362; +pub const KITTY_KEY_MENU: c_int = 57363; +pub const KITTY_KEY_F1: c_int = 57364; +pub const KITTY_KEY_F2: c_int = 57365; +pub const KITTY_KEY_F3: c_int = 57366; +pub const KITTY_KEY_F4: c_int = 57367; +pub const KITTY_KEY_F5: c_int = 57368; +pub const KITTY_KEY_F6: c_int = 57369; +pub const KITTY_KEY_F7: c_int = 57370; +pub const KITTY_KEY_F8: c_int = 57371; +pub const KITTY_KEY_F9: c_int = 57372; +pub const KITTY_KEY_F10: c_int = 57373; +pub const KITTY_KEY_F11: c_int = 57374; +pub const KITTY_KEY_F12: c_int = 57375; +pub const KITTY_KEY_F13: c_int = 57376; +pub const KITTY_KEY_F14: c_int = 57377; +pub const KITTY_KEY_F15: c_int = 57378; +pub const KITTY_KEY_F16: c_int = 57379; +pub const KITTY_KEY_F17: c_int = 57380; +pub const KITTY_KEY_F18: c_int = 57381; +pub const KITTY_KEY_F19: c_int = 57382; +pub const KITTY_KEY_F20: c_int = 57383; +pub const KITTY_KEY_F21: c_int = 57384; +pub const KITTY_KEY_F22: c_int = 57385; +pub const KITTY_KEY_F23: c_int = 57386; +pub const KITTY_KEY_F24: c_int = 57387; +pub const KITTY_KEY_F25: c_int = 57388; +pub const KITTY_KEY_F26: c_int = 57389; +pub const KITTY_KEY_F27: c_int = 57390; +pub const KITTY_KEY_F28: c_int = 57391; +pub const KITTY_KEY_F29: c_int = 57392; +pub const KITTY_KEY_F30: c_int = 57393; +pub const KITTY_KEY_F31: c_int = 57394; +pub const KITTY_KEY_F32: c_int = 57395; +pub const KITTY_KEY_F33: c_int = 57396; +pub const KITTY_KEY_F34: c_int = 57397; +pub const KITTY_KEY_F35: c_int = 57398; +pub const KITTY_KEY_KP_0: c_int = 57399; +pub const KITTY_KEY_KP_1: c_int = 57400; +pub const KITTY_KEY_KP_2: c_int = 57401; +pub const KITTY_KEY_KP_3: c_int = 57402; +pub const KITTY_KEY_KP_4: c_int = 57403; +pub const KITTY_KEY_KP_5: c_int = 57404; +pub const KITTY_KEY_KP_6: c_int = 57405; +pub const KITTY_KEY_KP_7: c_int = 57406; +pub const KITTY_KEY_KP_8: c_int = 57407; +pub const KITTY_KEY_KP_9: c_int = 57408; +pub const KITTY_KEY_KP_DECIMAL: c_int = 57409; +pub const KITTY_KEY_KP_DIVIDE: c_int = 57410; +pub const KITTY_KEY_KP_MULTIPLY: c_int = 57411; +pub const KITTY_KEY_KP_SUBTRACT: c_int = 57412; +pub const KITTY_KEY_KP_ADD: c_int = 57413; +pub const KITTY_KEY_KP_ENTER: c_int = 57414; +pub const KITTY_KEY_KP_EQUAL: c_int = 57415; +pub const KITTY_KEY_KP_SEPARATOR: c_int = 57416; +pub const KITTY_KEY_KP_LEFT: c_int = 57417; +pub const KITTY_KEY_KP_RIGHT: c_int = 57418; +pub const KITTY_KEY_KP_UP: c_int = 57419; +pub const KITTY_KEY_KP_DOWN: c_int = 57420; +pub const KITTY_KEY_KP_PAGE_UP: c_int = 57421; +pub const KITTY_KEY_KP_PAGE_DOWN: c_int = 57422; +pub const KITTY_KEY_KP_HOME: c_int = 57423; +pub const KITTY_KEY_KP_END: c_int = 57424; +pub const KITTY_KEY_KP_INSERT: c_int = 57425; +pub const KITTY_KEY_KP_DELETE: c_int = 57426; +pub const KITTY_KEY_KP_BEGIN: c_int = 57427; +pub const KITTY_KEY_MEDIA_PLAY: c_int = 57428; +pub const KITTY_KEY_MEDIA_PAUSE: c_int = 57429; +pub const KITTY_KEY_MEDIA_PLAY_PAUSE: c_int = 57430; +pub const KITTY_KEY_MEDIA_REVERSE: c_int = 57431; +pub const KITTY_KEY_MEDIA_STOP: c_int = 57432; +pub const KITTY_KEY_MEDIA_FAST_FORWARD: c_int = 57433; +pub const KITTY_KEY_MEDIA_REWIND: c_int = 57434; +pub const KITTY_KEY_MEDIA_TRACK_NEXT: c_int = 57435; +pub const KITTY_KEY_MEDIA_TRACK_PREVIOUS: c_int = 57436; +pub const KITTY_KEY_MEDIA_RECORD: c_int = 57437; +pub const KITTY_KEY_LOWER_VOLUME: c_int = 57438; +pub const KITTY_KEY_RAISE_VOLUME: c_int = 57439; +pub const KITTY_KEY_MUTE_VOLUME: c_int = 57440; +pub const KITTY_KEY_LEFT_SHIFT: c_int = 57441; +pub const KITTY_KEY_LEFT_CONTROL: c_int = 57442; +pub const KITTY_KEY_LEFT_ALT: c_int = 57443; +pub const KITTY_KEY_LEFT_SUPER: c_int = 57444; +pub const KITTY_KEY_LEFT_HYPER: c_int = 57445; +pub const KITTY_KEY_LEFT_META: c_int = 57446; +pub const KITTY_KEY_RIGHT_SHIFT: c_int = 57447; +pub const KITTY_KEY_RIGHT_CONTROL: c_int = 57448; +pub const KITTY_KEY_RIGHT_ALT: c_int = 57449; +pub const KITTY_KEY_RIGHT_SUPER: c_int = 57450; +pub const KITTY_KEY_RIGHT_HYPER: c_int = 57451; +pub const KITTY_KEY_RIGHT_META: c_int = 57452; +pub const KITTY_KEY_ISO_LEVEL3_SHIFT: c_int = 57453; +pub const KITTY_KEY_ISO_LEVEL5_SHIFT: c_int = 57454; +pub const KittyKey = c_uint; +pub const UIClientHandler = extern struct { + name: [*c]const u8, + @"fn": ?*const fn (Array) callconv(.C) void, +}; +pub extern var grid_line_buf_size: usize; +pub extern var grid_line_buf_char: [*c]schar_T; +pub extern var grid_line_buf_attr: [*c]sattr_T; +pub extern var ui_client_channel_id: u64; +pub extern var ui_client_attached: bool; +pub extern var ui_client_bg_response: TriState; +pub extern var ui_client_forward_stdin: bool; +pub extern fn ui_client_start_server(argc: c_int, argv: [*c][*c]u8) u64; +pub extern fn ui_client_attach(width: c_int, height: c_int, term: [*c]u8) void; +pub extern fn ui_client_detach() void; +pub extern fn ui_client_run(remote_ui: bool) noreturn; +pub extern fn ui_client_stop() void; +pub extern fn ui_client_set_size(width: c_int, height: c_int) void; +pub extern fn ui_client_get_redraw_handler(name: [*c]const u8, name_len: usize, @"error": [*c]Error) UIClientHandler; +pub extern fn handle_ui_client_redraw(channel_id: u64, args: Array, arena: [*c]Arena, @"error": [*c]Error) Object; +pub extern fn ui_client_event_grid_resize(args: Array) void; +pub extern fn ui_client_event_grid_line(args: Array) noreturn; +pub extern fn ui_client_event_raw_line(g: [*c]GridLineEvent) void; +pub extern fn ui_client_event_mode_info_set(args: Array) void; +pub extern fn ui_client_event_update_menu(args: Array) void; +pub extern fn ui_client_event_busy_start(args: Array) void; +pub extern fn ui_client_event_busy_stop(args: Array) void; +pub extern fn ui_client_event_mouse_on(args: Array) void; +pub extern fn ui_client_event_mouse_off(args: Array) void; +pub extern fn ui_client_event_mode_change(args: Array) void; +pub extern fn ui_client_event_bell(args: Array) void; +pub extern fn ui_client_event_visual_bell(args: Array) void; +pub extern fn ui_client_event_flush(args: Array) void; +pub extern fn ui_client_event_suspend(args: Array) void; +pub extern fn ui_client_event_set_title(args: Array) void; +pub extern fn ui_client_event_set_icon(args: Array) void; +pub extern fn ui_client_event_screenshot(args: Array) void; +pub extern fn ui_client_event_option_set(args: Array) void; +pub extern fn ui_client_event_default_colors_set(args: Array) void; +pub extern fn ui_client_event_hl_attr_define(args: Array) void; +pub extern fn ui_client_event_grid_clear(args: Array) void; +pub extern fn ui_client_event_grid_cursor_goto(args: Array) void; +pub extern fn ui_client_event_grid_scroll(args: Array) void; +pub extern fn ui_client_handler_hash(str: [*c]const u8, len: usize) c_int; +pub const kh_int_int_map_t = extern struct { + n_buckets: khint_t, + size: khint_t, + n_occupied: khint_t, + upper_bound: khint_t, + flags: [*c]khint32_t, + keys: [*c]c_int, + vals: [*c]c_int, +}; +pub extern fn kh_init_int_int_map() [*c]kh_int_int_map_t; +pub extern fn kh_dealloc_int_int_map(h: [*c]kh_int_int_map_t) void; +pub extern fn kh_destroy_int_int_map(h: [*c]kh_int_int_map_t) void; +pub extern fn kh_clear_int_int_map(h: [*c]kh_int_int_map_t) void; +pub extern fn kh_get_int_int_map(h: [*c]const kh_int_int_map_t, key: c_int) khint_t; +pub extern fn kh_resize_int_int_map(h: [*c]kh_int_int_map_t, new_n_buckets: khint_t) void; +pub extern fn kh_put_int_int_map(h: [*c]kh_int_int_map_t, key: c_int, ret: [*c]c_int) khint_t; +pub extern fn kh_del_int_int_map(h: [*c]kh_int_int_map_t, x: khint_t) void; +pub const Map_int_int = extern struct { + table: kh_int_int_map_t, +}; +pub extern fn map_int_int_new() [*c]Map_int_int; +pub extern fn map_int_int_free(map: [*c]Map_int_int) void; +pub extern fn map_int_int_destroy(map: [*c]Map_int_int) void; +pub extern fn map_int_int_get(map: [*c]Map_int_int, key: c_int) c_int; +pub extern fn map_int_int_has(map: [*c]Map_int_int, key: c_int) bool; +pub extern fn map_int_int_key(map: [*c]Map_int_int, key: c_int) c_int; +pub extern fn map_int_int_put(map: [*c]Map_int_int, key: c_int, value: c_int) c_int; +pub extern fn map_int_int_ref(map: [*c]Map_int_int, key: c_int, put: bool) [*c]c_int; +pub extern fn map_int_int_del(map: [*c]Map_int_int, key: c_int) c_int; +pub extern fn map_int_int_clear(map: [*c]Map_int_int) void; +pub const kh_int_cstr_t_map_t = extern struct { + n_buckets: khint_t, + size: khint_t, + n_occupied: khint_t, + upper_bound: khint_t, + flags: [*c]khint32_t, + keys: [*c]c_int, + vals: [*c]cstr_t, +}; +pub extern fn kh_init_int_cstr_t_map() [*c]kh_int_cstr_t_map_t; +pub extern fn kh_dealloc_int_cstr_t_map(h: [*c]kh_int_cstr_t_map_t) void; +pub extern fn kh_destroy_int_cstr_t_map(h: [*c]kh_int_cstr_t_map_t) void; +pub extern fn kh_clear_int_cstr_t_map(h: [*c]kh_int_cstr_t_map_t) void; +pub extern fn kh_get_int_cstr_t_map(h: [*c]const kh_int_cstr_t_map_t, key: c_int) khint_t; +pub extern fn kh_resize_int_cstr_t_map(h: [*c]kh_int_cstr_t_map_t, new_n_buckets: khint_t) void; +pub extern fn kh_put_int_cstr_t_map(h: [*c]kh_int_cstr_t_map_t, key: c_int, ret: [*c]c_int) khint_t; +pub extern fn kh_del_int_cstr_t_map(h: [*c]kh_int_cstr_t_map_t, x: khint_t) void; +pub const Map_int_cstr_t = extern struct { + table: kh_int_cstr_t_map_t, +}; +pub extern fn map_int_cstr_t_new() [*c]Map_int_cstr_t; +pub extern fn map_int_cstr_t_free(map: [*c]Map_int_cstr_t) void; +pub extern fn map_int_cstr_t_destroy(map: [*c]Map_int_cstr_t) void; +pub extern fn map_int_cstr_t_get(map: [*c]Map_int_cstr_t, key: c_int) cstr_t; +pub extern fn map_int_cstr_t_has(map: [*c]Map_int_cstr_t, key: c_int) bool; +pub extern fn map_int_cstr_t_key(map: [*c]Map_int_cstr_t, key: c_int) c_int; +pub extern fn map_int_cstr_t_put(map: [*c]Map_int_cstr_t, key: c_int, value: cstr_t) cstr_t; +pub extern fn map_int_cstr_t_ref(map: [*c]Map_int_cstr_t, key: c_int, put: bool) [*c]cstr_t; +pub extern fn map_int_cstr_t_del(map: [*c]Map_int_cstr_t, key: c_int) cstr_t; +pub extern fn map_int_cstr_t_clear(map: [*c]Map_int_cstr_t) void; +pub const kh_cstr_t_ptr_t_map_t = extern struct { + n_buckets: khint_t, + size: khint_t, + n_occupied: khint_t, + upper_bound: khint_t, + flags: [*c]khint32_t, + keys: [*c]cstr_t, + vals: [*c]ptr_t, +}; +pub extern fn kh_init_cstr_t_ptr_t_map() [*c]kh_cstr_t_ptr_t_map_t; +pub extern fn kh_dealloc_cstr_t_ptr_t_map(h: [*c]kh_cstr_t_ptr_t_map_t) void; +pub extern fn kh_destroy_cstr_t_ptr_t_map(h: [*c]kh_cstr_t_ptr_t_map_t) void; +pub extern fn kh_clear_cstr_t_ptr_t_map(h: [*c]kh_cstr_t_ptr_t_map_t) void; +pub extern fn kh_get_cstr_t_ptr_t_map(h: [*c]const kh_cstr_t_ptr_t_map_t, key: cstr_t) khint_t; +pub extern fn kh_resize_cstr_t_ptr_t_map(h: [*c]kh_cstr_t_ptr_t_map_t, new_n_buckets: khint_t) void; +pub extern fn kh_put_cstr_t_ptr_t_map(h: [*c]kh_cstr_t_ptr_t_map_t, key: cstr_t, ret: [*c]c_int) khint_t; +pub extern fn kh_del_cstr_t_ptr_t_map(h: [*c]kh_cstr_t_ptr_t_map_t, x: khint_t) void; +pub const Map_cstr_t_ptr_t = extern struct { + table: kh_cstr_t_ptr_t_map_t, +}; +pub extern fn map_cstr_t_ptr_t_new() [*c]Map_cstr_t_ptr_t; +pub extern fn map_cstr_t_ptr_t_free(map: [*c]Map_cstr_t_ptr_t) void; +pub extern fn map_cstr_t_ptr_t_destroy(map: [*c]Map_cstr_t_ptr_t) void; +pub extern fn map_cstr_t_ptr_t_get(map: [*c]Map_cstr_t_ptr_t, key: cstr_t) ptr_t; +pub extern fn map_cstr_t_ptr_t_has(map: [*c]Map_cstr_t_ptr_t, key: cstr_t) bool; +pub extern fn map_cstr_t_ptr_t_key(map: [*c]Map_cstr_t_ptr_t, key: cstr_t) cstr_t; +pub extern fn map_cstr_t_ptr_t_put(map: [*c]Map_cstr_t_ptr_t, key: cstr_t, value: ptr_t) ptr_t; +pub extern fn map_cstr_t_ptr_t_ref(map: [*c]Map_cstr_t_ptr_t, key: cstr_t, put: bool) [*c]ptr_t; +pub extern fn map_cstr_t_ptr_t_del(map: [*c]Map_cstr_t_ptr_t, key: cstr_t) ptr_t; +pub extern fn map_cstr_t_ptr_t_clear(map: [*c]Map_cstr_t_ptr_t) void; +pub const kh_cstr_t_int_map_t = extern struct { + n_buckets: khint_t, + size: khint_t, + n_occupied: khint_t, + upper_bound: khint_t, + flags: [*c]khint32_t, + keys: [*c]cstr_t, + vals: [*c]c_int, +}; +pub extern fn kh_init_cstr_t_int_map() [*c]kh_cstr_t_int_map_t; +pub extern fn kh_dealloc_cstr_t_int_map(h: [*c]kh_cstr_t_int_map_t) void; +pub extern fn kh_destroy_cstr_t_int_map(h: [*c]kh_cstr_t_int_map_t) void; +pub extern fn kh_clear_cstr_t_int_map(h: [*c]kh_cstr_t_int_map_t) void; +pub extern fn kh_get_cstr_t_int_map(h: [*c]const kh_cstr_t_int_map_t, key: cstr_t) khint_t; +pub extern fn kh_resize_cstr_t_int_map(h: [*c]kh_cstr_t_int_map_t, new_n_buckets: khint_t) void; +pub extern fn kh_put_cstr_t_int_map(h: [*c]kh_cstr_t_int_map_t, key: cstr_t, ret: [*c]c_int) khint_t; +pub extern fn kh_del_cstr_t_int_map(h: [*c]kh_cstr_t_int_map_t, x: khint_t) void; +pub const Map_cstr_t_int = extern struct { + table: kh_cstr_t_int_map_t, +}; +pub extern fn map_cstr_t_int_new() [*c]Map_cstr_t_int; +pub extern fn map_cstr_t_int_free(map: [*c]Map_cstr_t_int) void; +pub extern fn map_cstr_t_int_destroy(map: [*c]Map_cstr_t_int) void; +pub extern fn map_cstr_t_int_get(map: [*c]Map_cstr_t_int, key: cstr_t) c_int; +pub extern fn map_cstr_t_int_has(map: [*c]Map_cstr_t_int, key: cstr_t) bool; +pub extern fn map_cstr_t_int_key(map: [*c]Map_cstr_t_int, key: cstr_t) cstr_t; +pub extern fn map_cstr_t_int_put(map: [*c]Map_cstr_t_int, key: cstr_t, value: c_int) c_int; +pub extern fn map_cstr_t_int_ref(map: [*c]Map_cstr_t_int, key: cstr_t, put: bool) [*c]c_int; +pub extern fn map_cstr_t_int_del(map: [*c]Map_cstr_t_int, key: cstr_t) c_int; +pub extern fn map_cstr_t_int_clear(map: [*c]Map_cstr_t_int) void; +pub const kh_ptr_t_ptr_t_map_t = extern struct { + n_buckets: khint_t, + size: khint_t, + n_occupied: khint_t, + upper_bound: khint_t, + flags: [*c]khint32_t, + keys: [*c]ptr_t, + vals: [*c]ptr_t, +}; +pub extern fn kh_init_ptr_t_ptr_t_map() [*c]kh_ptr_t_ptr_t_map_t; +pub extern fn kh_dealloc_ptr_t_ptr_t_map(h: [*c]kh_ptr_t_ptr_t_map_t) void; +pub extern fn kh_destroy_ptr_t_ptr_t_map(h: [*c]kh_ptr_t_ptr_t_map_t) void; +pub extern fn kh_clear_ptr_t_ptr_t_map(h: [*c]kh_ptr_t_ptr_t_map_t) void; +pub extern fn kh_get_ptr_t_ptr_t_map(h: [*c]const kh_ptr_t_ptr_t_map_t, key: ptr_t) khint_t; +pub extern fn kh_resize_ptr_t_ptr_t_map(h: [*c]kh_ptr_t_ptr_t_map_t, new_n_buckets: khint_t) void; +pub extern fn kh_put_ptr_t_ptr_t_map(h: [*c]kh_ptr_t_ptr_t_map_t, key: ptr_t, ret: [*c]c_int) khint_t; +pub extern fn kh_del_ptr_t_ptr_t_map(h: [*c]kh_ptr_t_ptr_t_map_t, x: khint_t) void; +pub const Map_ptr_t_ptr_t = extern struct { + table: kh_ptr_t_ptr_t_map_t, +}; +pub extern fn map_ptr_t_ptr_t_new() [*c]Map_ptr_t_ptr_t; +pub extern fn map_ptr_t_ptr_t_free(map: [*c]Map_ptr_t_ptr_t) void; +pub extern fn map_ptr_t_ptr_t_destroy(map: [*c]Map_ptr_t_ptr_t) void; +pub extern fn map_ptr_t_ptr_t_get(map: [*c]Map_ptr_t_ptr_t, key: ptr_t) ptr_t; +pub extern fn map_ptr_t_ptr_t_has(map: [*c]Map_ptr_t_ptr_t, key: ptr_t) bool; +pub extern fn map_ptr_t_ptr_t_key(map: [*c]Map_ptr_t_ptr_t, key: ptr_t) ptr_t; +pub extern fn map_ptr_t_ptr_t_put(map: [*c]Map_ptr_t_ptr_t, key: ptr_t, value: ptr_t) ptr_t; +pub extern fn map_ptr_t_ptr_t_ref(map: [*c]Map_ptr_t_ptr_t, key: ptr_t, put: bool) [*c]ptr_t; +pub extern fn map_ptr_t_ptr_t_del(map: [*c]Map_ptr_t_ptr_t, key: ptr_t) ptr_t; +pub extern fn map_ptr_t_ptr_t_clear(map: [*c]Map_ptr_t_ptr_t) void; +pub const kh_uint32_t_ptr_t_map_t = extern struct { + n_buckets: khint_t, + size: khint_t, + n_occupied: khint_t, + upper_bound: khint_t, + flags: [*c]khint32_t, + keys: [*c]u32, + vals: [*c]ptr_t, +}; +pub extern fn kh_init_uint32_t_ptr_t_map() [*c]kh_uint32_t_ptr_t_map_t; +pub extern fn kh_dealloc_uint32_t_ptr_t_map(h: [*c]kh_uint32_t_ptr_t_map_t) void; +pub extern fn kh_destroy_uint32_t_ptr_t_map(h: [*c]kh_uint32_t_ptr_t_map_t) void; +pub extern fn kh_clear_uint32_t_ptr_t_map(h: [*c]kh_uint32_t_ptr_t_map_t) void; +pub extern fn kh_get_uint32_t_ptr_t_map(h: [*c]const kh_uint32_t_ptr_t_map_t, key: u32) khint_t; +pub extern fn kh_resize_uint32_t_ptr_t_map(h: [*c]kh_uint32_t_ptr_t_map_t, new_n_buckets: khint_t) void; +pub extern fn kh_put_uint32_t_ptr_t_map(h: [*c]kh_uint32_t_ptr_t_map_t, key: u32, ret: [*c]c_int) khint_t; +pub extern fn kh_del_uint32_t_ptr_t_map(h: [*c]kh_uint32_t_ptr_t_map_t, x: khint_t) void; +pub const Map_uint32_t_ptr_t = extern struct { + table: kh_uint32_t_ptr_t_map_t, +}; +pub extern fn map_uint32_t_ptr_t_new() [*c]Map_uint32_t_ptr_t; +pub extern fn map_uint32_t_ptr_t_free(map: [*c]Map_uint32_t_ptr_t) void; +pub extern fn map_uint32_t_ptr_t_destroy(map: [*c]Map_uint32_t_ptr_t) void; +pub extern fn map_uint32_t_ptr_t_get(map: [*c]Map_uint32_t_ptr_t, key: u32) ptr_t; +pub extern fn map_uint32_t_ptr_t_has(map: [*c]Map_uint32_t_ptr_t, key: u32) bool; +pub extern fn map_uint32_t_ptr_t_key(map: [*c]Map_uint32_t_ptr_t, key: u32) u32; +pub extern fn map_uint32_t_ptr_t_put(map: [*c]Map_uint32_t_ptr_t, key: u32, value: ptr_t) ptr_t; +pub extern fn map_uint32_t_ptr_t_ref(map: [*c]Map_uint32_t_ptr_t, key: u32, put: bool) [*c]ptr_t; +pub extern fn map_uint32_t_ptr_t_del(map: [*c]Map_uint32_t_ptr_t, key: u32) ptr_t; +pub extern fn map_uint32_t_ptr_t_clear(map: [*c]Map_uint32_t_ptr_t) void; +pub const kh_uint64_t_ptr_t_map_t = extern struct { + n_buckets: khint_t, + size: khint_t, + n_occupied: khint_t, + upper_bound: khint_t, + flags: [*c]khint32_t, + keys: [*c]u64, + vals: [*c]ptr_t, +}; +pub extern fn kh_init_uint64_t_ptr_t_map() [*c]kh_uint64_t_ptr_t_map_t; +pub extern fn kh_dealloc_uint64_t_ptr_t_map(h: [*c]kh_uint64_t_ptr_t_map_t) void; +pub extern fn kh_destroy_uint64_t_ptr_t_map(h: [*c]kh_uint64_t_ptr_t_map_t) void; +pub extern fn kh_clear_uint64_t_ptr_t_map(h: [*c]kh_uint64_t_ptr_t_map_t) void; +pub extern fn kh_get_uint64_t_ptr_t_map(h: [*c]const kh_uint64_t_ptr_t_map_t, key: u64) khint_t; +pub extern fn kh_resize_uint64_t_ptr_t_map(h: [*c]kh_uint64_t_ptr_t_map_t, new_n_buckets: khint_t) void; +pub extern fn kh_put_uint64_t_ptr_t_map(h: [*c]kh_uint64_t_ptr_t_map_t, key: u64, ret: [*c]c_int) khint_t; +pub extern fn kh_del_uint64_t_ptr_t_map(h: [*c]kh_uint64_t_ptr_t_map_t, x: khint_t) void; +pub const Map_uint64_t_ptr_t = extern struct { + table: kh_uint64_t_ptr_t_map_t, +}; +pub extern fn map_uint64_t_ptr_t_new() [*c]Map_uint64_t_ptr_t; +pub extern fn map_uint64_t_ptr_t_free(map: [*c]Map_uint64_t_ptr_t) void; +pub extern fn map_uint64_t_ptr_t_destroy(map: [*c]Map_uint64_t_ptr_t) void; +pub extern fn map_uint64_t_ptr_t_get(map: [*c]Map_uint64_t_ptr_t, key: u64) ptr_t; +pub extern fn map_uint64_t_ptr_t_has(map: [*c]Map_uint64_t_ptr_t, key: u64) bool; +pub extern fn map_uint64_t_ptr_t_key(map: [*c]Map_uint64_t_ptr_t, key: u64) u64; +pub extern fn map_uint64_t_ptr_t_put(map: [*c]Map_uint64_t_ptr_t, key: u64, value: ptr_t) ptr_t; +pub extern fn map_uint64_t_ptr_t_ref(map: [*c]Map_uint64_t_ptr_t, key: u64, put: bool) [*c]ptr_t; +pub extern fn map_uint64_t_ptr_t_del(map: [*c]Map_uint64_t_ptr_t, key: u64) ptr_t; +pub extern fn map_uint64_t_ptr_t_clear(map: [*c]Map_uint64_t_ptr_t) void; +pub const kh_uint64_t_ssize_t_map_t = extern struct { + n_buckets: khint_t, + size: khint_t, + n_occupied: khint_t, + upper_bound: khint_t, + flags: [*c]khint32_t, + keys: [*c]u64, + vals: [*c]isize, +}; +pub extern fn kh_init_uint64_t_ssize_t_map() [*c]kh_uint64_t_ssize_t_map_t; +pub extern fn kh_dealloc_uint64_t_ssize_t_map(h: [*c]kh_uint64_t_ssize_t_map_t) void; +pub extern fn kh_destroy_uint64_t_ssize_t_map(h: [*c]kh_uint64_t_ssize_t_map_t) void; +pub extern fn kh_clear_uint64_t_ssize_t_map(h: [*c]kh_uint64_t_ssize_t_map_t) void; +pub extern fn kh_get_uint64_t_ssize_t_map(h: [*c]const kh_uint64_t_ssize_t_map_t, key: u64) khint_t; +pub extern fn kh_resize_uint64_t_ssize_t_map(h: [*c]kh_uint64_t_ssize_t_map_t, new_n_buckets: khint_t) void; +pub extern fn kh_put_uint64_t_ssize_t_map(h: [*c]kh_uint64_t_ssize_t_map_t, key: u64, ret: [*c]c_int) khint_t; +pub extern fn kh_del_uint64_t_ssize_t_map(h: [*c]kh_uint64_t_ssize_t_map_t, x: khint_t) void; +pub const Map_uint64_t_ssize_t = extern struct { + table: kh_uint64_t_ssize_t_map_t, +}; +pub extern fn map_uint64_t_ssize_t_new() [*c]Map_uint64_t_ssize_t; +pub extern fn map_uint64_t_ssize_t_free(map: [*c]Map_uint64_t_ssize_t) void; +pub extern fn map_uint64_t_ssize_t_destroy(map: [*c]Map_uint64_t_ssize_t) void; +pub extern fn map_uint64_t_ssize_t_get(map: [*c]Map_uint64_t_ssize_t, key: u64) isize; +pub extern fn map_uint64_t_ssize_t_has(map: [*c]Map_uint64_t_ssize_t, key: u64) bool; +pub extern fn map_uint64_t_ssize_t_key(map: [*c]Map_uint64_t_ssize_t, key: u64) u64; +pub extern fn map_uint64_t_ssize_t_put(map: [*c]Map_uint64_t_ssize_t, key: u64, value: isize) isize; +pub extern fn map_uint64_t_ssize_t_ref(map: [*c]Map_uint64_t_ssize_t, key: u64, put: bool) [*c]isize; +pub extern fn map_uint64_t_ssize_t_del(map: [*c]Map_uint64_t_ssize_t, key: u64) isize; +pub extern fn map_uint64_t_ssize_t_clear(map: [*c]Map_uint64_t_ssize_t) void; +pub const kh_uint64_t_uint64_t_map_t = extern struct { + n_buckets: khint_t, + size: khint_t, + n_occupied: khint_t, + upper_bound: khint_t, + flags: [*c]khint32_t, + keys: [*c]u64, + vals: [*c]u64, +}; +pub extern fn kh_init_uint64_t_uint64_t_map() [*c]kh_uint64_t_uint64_t_map_t; +pub extern fn kh_dealloc_uint64_t_uint64_t_map(h: [*c]kh_uint64_t_uint64_t_map_t) void; +pub extern fn kh_destroy_uint64_t_uint64_t_map(h: [*c]kh_uint64_t_uint64_t_map_t) void; +pub extern fn kh_clear_uint64_t_uint64_t_map(h: [*c]kh_uint64_t_uint64_t_map_t) void; +pub extern fn kh_get_uint64_t_uint64_t_map(h: [*c]const kh_uint64_t_uint64_t_map_t, key: u64) khint_t; +pub extern fn kh_resize_uint64_t_uint64_t_map(h: [*c]kh_uint64_t_uint64_t_map_t, new_n_buckets: khint_t) void; +pub extern fn kh_put_uint64_t_uint64_t_map(h: [*c]kh_uint64_t_uint64_t_map_t, key: u64, ret: [*c]c_int) khint_t; +pub extern fn kh_del_uint64_t_uint64_t_map(h: [*c]kh_uint64_t_uint64_t_map_t, x: khint_t) void; +pub const Map_uint64_t_uint64_t = extern struct { + table: kh_uint64_t_uint64_t_map_t, +}; +pub extern fn map_uint64_t_uint64_t_new() [*c]Map_uint64_t_uint64_t; +pub extern fn map_uint64_t_uint64_t_free(map: [*c]Map_uint64_t_uint64_t) void; +pub extern fn map_uint64_t_uint64_t_destroy(map: [*c]Map_uint64_t_uint64_t) void; +pub extern fn map_uint64_t_uint64_t_get(map: [*c]Map_uint64_t_uint64_t, key: u64) u64; +pub extern fn map_uint64_t_uint64_t_has(map: [*c]Map_uint64_t_uint64_t, key: u64) bool; +pub extern fn map_uint64_t_uint64_t_key(map: [*c]Map_uint64_t_uint64_t, key: u64) u64; +pub extern fn map_uint64_t_uint64_t_put(map: [*c]Map_uint64_t_uint64_t, key: u64, value: u64) u64; +pub extern fn map_uint64_t_uint64_t_ref(map: [*c]Map_uint64_t_uint64_t, key: u64, put: bool) [*c]u64; +pub extern fn map_uint64_t_uint64_t_del(map: [*c]Map_uint64_t_uint64_t, key: u64) u64; +pub extern fn map_uint64_t_uint64_t_clear(map: [*c]Map_uint64_t_uint64_t) void; +pub const kh_uint32_t_uint32_t_map_t = extern struct { + n_buckets: khint_t, + size: khint_t, + n_occupied: khint_t, + upper_bound: khint_t, + flags: [*c]khint32_t, + keys: [*c]u32, + vals: [*c]u32, +}; +pub extern fn kh_init_uint32_t_uint32_t_map() [*c]kh_uint32_t_uint32_t_map_t; +pub extern fn kh_dealloc_uint32_t_uint32_t_map(h: [*c]kh_uint32_t_uint32_t_map_t) void; +pub extern fn kh_destroy_uint32_t_uint32_t_map(h: [*c]kh_uint32_t_uint32_t_map_t) void; +pub extern fn kh_clear_uint32_t_uint32_t_map(h: [*c]kh_uint32_t_uint32_t_map_t) void; +pub extern fn kh_get_uint32_t_uint32_t_map(h: [*c]const kh_uint32_t_uint32_t_map_t, key: u32) khint_t; +pub extern fn kh_resize_uint32_t_uint32_t_map(h: [*c]kh_uint32_t_uint32_t_map_t, new_n_buckets: khint_t) void; +pub extern fn kh_put_uint32_t_uint32_t_map(h: [*c]kh_uint32_t_uint32_t_map_t, key: u32, ret: [*c]c_int) khint_t; +pub extern fn kh_del_uint32_t_uint32_t_map(h: [*c]kh_uint32_t_uint32_t_map_t, x: khint_t) void; +pub const Map_uint32_t_uint32_t = extern struct { + table: kh_uint32_t_uint32_t_map_t, +}; +pub extern fn map_uint32_t_uint32_t_new() [*c]Map_uint32_t_uint32_t; +pub extern fn map_uint32_t_uint32_t_free(map: [*c]Map_uint32_t_uint32_t) void; +pub extern fn map_uint32_t_uint32_t_destroy(map: [*c]Map_uint32_t_uint32_t) void; +pub extern fn map_uint32_t_uint32_t_get(map: [*c]Map_uint32_t_uint32_t, key: u32) u32; +pub extern fn map_uint32_t_uint32_t_has(map: [*c]Map_uint32_t_uint32_t, key: u32) bool; +pub extern fn map_uint32_t_uint32_t_key(map: [*c]Map_uint32_t_uint32_t, key: u32) u32; +pub extern fn map_uint32_t_uint32_t_put(map: [*c]Map_uint32_t_uint32_t, key: u32, value: u32) u32; +pub extern fn map_uint32_t_uint32_t_ref(map: [*c]Map_uint32_t_uint32_t, key: u32, put: bool) [*c]u32; +pub extern fn map_uint32_t_uint32_t_del(map: [*c]Map_uint32_t_uint32_t, key: u32) u32; +pub extern fn map_uint32_t_uint32_t_clear(map: [*c]Map_uint32_t_uint32_t) void; +pub const kh_handle_T_ptr_t_map_t = extern struct { + n_buckets: khint_t, + size: khint_t, + n_occupied: khint_t, + upper_bound: khint_t, + flags: [*c]khint32_t, + keys: [*c]handle_T, + vals: [*c]ptr_t, +}; +pub extern fn kh_init_handle_T_ptr_t_map() [*c]kh_handle_T_ptr_t_map_t; +pub extern fn kh_dealloc_handle_T_ptr_t_map(h: [*c]kh_handle_T_ptr_t_map_t) void; +pub extern fn kh_destroy_handle_T_ptr_t_map(h: [*c]kh_handle_T_ptr_t_map_t) void; +pub extern fn kh_clear_handle_T_ptr_t_map(h: [*c]kh_handle_T_ptr_t_map_t) void; +pub extern fn kh_get_handle_T_ptr_t_map(h: [*c]const kh_handle_T_ptr_t_map_t, key: handle_T) khint_t; +pub extern fn kh_resize_handle_T_ptr_t_map(h: [*c]kh_handle_T_ptr_t_map_t, new_n_buckets: khint_t) void; +pub extern fn kh_put_handle_T_ptr_t_map(h: [*c]kh_handle_T_ptr_t_map_t, key: handle_T, ret: [*c]c_int) khint_t; +pub extern fn kh_del_handle_T_ptr_t_map(h: [*c]kh_handle_T_ptr_t_map_t, x: khint_t) void; +pub const Map_handle_T_ptr_t = extern struct { + table: kh_handle_T_ptr_t_map_t, +}; +pub extern fn map_handle_T_ptr_t_new() [*c]Map_handle_T_ptr_t; +pub extern fn map_handle_T_ptr_t_free(map: [*c]Map_handle_T_ptr_t) void; +pub extern fn map_handle_T_ptr_t_destroy(map: [*c]Map_handle_T_ptr_t) void; +pub extern fn map_handle_T_ptr_t_get(map: [*c]Map_handle_T_ptr_t, key: handle_T) ptr_t; +pub extern fn map_handle_T_ptr_t_has(map: [*c]Map_handle_T_ptr_t, key: handle_T) bool; +pub extern fn map_handle_T_ptr_t_key(map: [*c]Map_handle_T_ptr_t, key: handle_T) handle_T; +pub extern fn map_handle_T_ptr_t_put(map: [*c]Map_handle_T_ptr_t, key: handle_T, value: ptr_t) ptr_t; +pub extern fn map_handle_T_ptr_t_ref(map: [*c]Map_handle_T_ptr_t, key: handle_T, put: bool) [*c]ptr_t; +pub extern fn map_handle_T_ptr_t_del(map: [*c]Map_handle_T_ptr_t, key: handle_T) ptr_t; +pub extern fn map_handle_T_ptr_t_clear(map: [*c]Map_handle_T_ptr_t) void; +pub const kh_HlEntry_int_map_t = extern struct { + n_buckets: khint_t, + size: khint_t, + n_occupied: khint_t, + upper_bound: khint_t, + flags: [*c]khint32_t, + keys: [*c]HlEntry, + vals: [*c]c_int, +}; +pub extern fn kh_init_HlEntry_int_map() [*c]kh_HlEntry_int_map_t; +pub extern fn kh_dealloc_HlEntry_int_map(h: [*c]kh_HlEntry_int_map_t) void; +pub extern fn kh_destroy_HlEntry_int_map(h: [*c]kh_HlEntry_int_map_t) void; +pub extern fn kh_clear_HlEntry_int_map(h: [*c]kh_HlEntry_int_map_t) void; +pub extern fn kh_get_HlEntry_int_map(h: [*c]const kh_HlEntry_int_map_t, key: HlEntry) khint_t; +pub extern fn kh_resize_HlEntry_int_map(h: [*c]kh_HlEntry_int_map_t, new_n_buckets: khint_t) void; +pub extern fn kh_put_HlEntry_int_map(h: [*c]kh_HlEntry_int_map_t, key: HlEntry, ret: [*c]c_int) khint_t; +pub extern fn kh_del_HlEntry_int_map(h: [*c]kh_HlEntry_int_map_t, x: khint_t) void; +pub const Map_HlEntry_int = extern struct { + table: kh_HlEntry_int_map_t, +}; +pub extern fn map_HlEntry_int_new() [*c]Map_HlEntry_int; +pub extern fn map_HlEntry_int_free(map: [*c]Map_HlEntry_int) void; +pub extern fn map_HlEntry_int_destroy(map: [*c]Map_HlEntry_int) void; +pub extern fn map_HlEntry_int_get(map: [*c]Map_HlEntry_int, key: HlEntry) c_int; +pub extern fn map_HlEntry_int_has(map: [*c]Map_HlEntry_int, key: HlEntry) bool; +pub extern fn map_HlEntry_int_key(map: [*c]Map_HlEntry_int, key: HlEntry) HlEntry; +pub extern fn map_HlEntry_int_put(map: [*c]Map_HlEntry_int, key: HlEntry, value: c_int) c_int; +pub extern fn map_HlEntry_int_ref(map: [*c]Map_HlEntry_int, key: HlEntry, put: bool) [*c]c_int; +pub extern fn map_HlEntry_int_del(map: [*c]Map_HlEntry_int, key: HlEntry) c_int; +pub extern fn map_HlEntry_int_clear(map: [*c]Map_HlEntry_int) void; +pub const kh_String_handle_T_map_t = extern struct { + n_buckets: khint_t, + size: khint_t, + n_occupied: khint_t, + upper_bound: khint_t, + flags: [*c]khint32_t, + keys: [*c]String, + vals: [*c]handle_T, +}; +pub extern fn kh_init_String_handle_T_map() [*c]kh_String_handle_T_map_t; +pub extern fn kh_dealloc_String_handle_T_map(h: [*c]kh_String_handle_T_map_t) void; +pub extern fn kh_destroy_String_handle_T_map(h: [*c]kh_String_handle_T_map_t) void; +pub extern fn kh_clear_String_handle_T_map(h: [*c]kh_String_handle_T_map_t) void; +pub extern fn kh_get_String_handle_T_map(h: [*c]const kh_String_handle_T_map_t, key: String) khint_t; +pub extern fn kh_resize_String_handle_T_map(h: [*c]kh_String_handle_T_map_t, new_n_buckets: khint_t) void; +pub extern fn kh_put_String_handle_T_map(h: [*c]kh_String_handle_T_map_t, key: String, ret: [*c]c_int) khint_t; +pub extern fn kh_del_String_handle_T_map(h: [*c]kh_String_handle_T_map_t, x: khint_t) void; +pub const Map_String_handle_T = extern struct { + table: kh_String_handle_T_map_t, +}; +pub extern fn map_String_handle_T_new() [*c]Map_String_handle_T; +pub extern fn map_String_handle_T_free(map: [*c]Map_String_handle_T) void; +pub extern fn map_String_handle_T_destroy(map: [*c]Map_String_handle_T) void; +pub extern fn map_String_handle_T_get(map: [*c]Map_String_handle_T, key: String) handle_T; +pub extern fn map_String_handle_T_has(map: [*c]Map_String_handle_T, key: String) bool; +pub extern fn map_String_handle_T_key(map: [*c]Map_String_handle_T, key: String) String; +pub extern fn map_String_handle_T_put(map: [*c]Map_String_handle_T, key: String, value: handle_T) handle_T; +pub extern fn map_String_handle_T_ref(map: [*c]Map_String_handle_T, key: String, put: bool) [*c]handle_T; +pub extern fn map_String_handle_T_del(map: [*c]Map_String_handle_T, key: String) handle_T; +pub extern fn map_String_handle_T_clear(map: [*c]Map_String_handle_T) void; +pub const kh_String_int_map_t = extern struct { + n_buckets: khint_t, + size: khint_t, + n_occupied: khint_t, + upper_bound: khint_t, + flags: [*c]khint32_t, + keys: [*c]String, + vals: [*c]c_int, +}; +pub extern fn kh_init_String_int_map() [*c]kh_String_int_map_t; +pub extern fn kh_dealloc_String_int_map(h: [*c]kh_String_int_map_t) void; +pub extern fn kh_destroy_String_int_map(h: [*c]kh_String_int_map_t) void; +pub extern fn kh_clear_String_int_map(h: [*c]kh_String_int_map_t) void; +pub extern fn kh_get_String_int_map(h: [*c]const kh_String_int_map_t, key: String) khint_t; +pub extern fn kh_resize_String_int_map(h: [*c]kh_String_int_map_t, new_n_buckets: khint_t) void; +pub extern fn kh_put_String_int_map(h: [*c]kh_String_int_map_t, key: String, ret: [*c]c_int) khint_t; +pub extern fn kh_del_String_int_map(h: [*c]kh_String_int_map_t, x: khint_t) void; +pub const Map_String_int = extern struct { + table: kh_String_int_map_t, +}; +pub extern fn map_String_int_new() [*c]Map_String_int; +pub extern fn map_String_int_free(map: [*c]Map_String_int) void; +pub extern fn map_String_int_destroy(map: [*c]Map_String_int) void; +pub extern fn map_String_int_get(map: [*c]Map_String_int, key: String) c_int; +pub extern fn map_String_int_has(map: [*c]Map_String_int, key: String) bool; +pub extern fn map_String_int_key(map: [*c]Map_String_int, key: String) String; +pub extern fn map_String_int_put(map: [*c]Map_String_int, key: String, value: c_int) c_int; +pub extern fn map_String_int_ref(map: [*c]Map_String_int, key: String, put: bool) [*c]c_int; +pub extern fn map_String_int_del(map: [*c]Map_String_int, key: String) c_int; +pub extern fn map_String_int_clear(map: [*c]Map_String_int) void; +pub const kh_int_String_map_t = extern struct { + n_buckets: khint_t, + size: khint_t, + n_occupied: khint_t, + upper_bound: khint_t, + flags: [*c]khint32_t, + keys: [*c]c_int, + vals: [*c]String, +}; +pub extern fn kh_init_int_String_map() [*c]kh_int_String_map_t; +pub extern fn kh_dealloc_int_String_map(h: [*c]kh_int_String_map_t) void; +pub extern fn kh_destroy_int_String_map(h: [*c]kh_int_String_map_t) void; +pub extern fn kh_clear_int_String_map(h: [*c]kh_int_String_map_t) void; +pub extern fn kh_get_int_String_map(h: [*c]const kh_int_String_map_t, key: c_int) khint_t; +pub extern fn kh_resize_int_String_map(h: [*c]kh_int_String_map_t, new_n_buckets: khint_t) void; +pub extern fn kh_put_int_String_map(h: [*c]kh_int_String_map_t, key: c_int, ret: [*c]c_int) khint_t; +pub extern fn kh_del_int_String_map(h: [*c]kh_int_String_map_t, x: khint_t) void; +pub const Map_int_String = extern struct { + table: kh_int_String_map_t, +}; +pub extern fn map_int_String_new() [*c]Map_int_String; +pub extern fn map_int_String_free(map: [*c]Map_int_String) void; +pub extern fn map_int_String_destroy(map: [*c]Map_int_String) void; +pub extern fn map_int_String_get(map: [*c]Map_int_String, key: c_int) String; +pub extern fn map_int_String_has(map: [*c]Map_int_String, key: c_int) bool; +pub extern fn map_int_String_key(map: [*c]Map_int_String, key: c_int) c_int; +pub extern fn map_int_String_put(map: [*c]Map_int_String, key: c_int, value: String) String; +pub extern fn map_int_String_ref(map: [*c]Map_int_String, key: c_int, put: bool) [*c]String; +pub extern fn map_int_String_del(map: [*c]Map_int_String, key: c_int) String; +pub extern fn map_int_String_clear(map: [*c]Map_int_String) void; +pub const kh_ColorKey_ColorItem_map_t = extern struct { + n_buckets: khint_t, + size: khint_t, + n_occupied: khint_t, + upper_bound: khint_t, + flags: [*c]khint32_t, + keys: [*c]ColorKey, + vals: [*c]ColorItem, +}; +pub extern fn kh_init_ColorKey_ColorItem_map() [*c]kh_ColorKey_ColorItem_map_t; +pub extern fn kh_dealloc_ColorKey_ColorItem_map(h: [*c]kh_ColorKey_ColorItem_map_t) void; +pub extern fn kh_destroy_ColorKey_ColorItem_map(h: [*c]kh_ColorKey_ColorItem_map_t) void; +pub extern fn kh_clear_ColorKey_ColorItem_map(h: [*c]kh_ColorKey_ColorItem_map_t) void; +pub extern fn kh_get_ColorKey_ColorItem_map(h: [*c]const kh_ColorKey_ColorItem_map_t, key: ColorKey) khint_t; +pub extern fn kh_resize_ColorKey_ColorItem_map(h: [*c]kh_ColorKey_ColorItem_map_t, new_n_buckets: khint_t) void; +pub extern fn kh_put_ColorKey_ColorItem_map(h: [*c]kh_ColorKey_ColorItem_map_t, key: ColorKey, ret: [*c]c_int) khint_t; +pub extern fn kh_del_ColorKey_ColorItem_map(h: [*c]kh_ColorKey_ColorItem_map_t, x: khint_t) void; +pub const Map_ColorKey_ColorItem = extern struct { + table: kh_ColorKey_ColorItem_map_t, +}; +pub extern fn map_ColorKey_ColorItem_new() [*c]Map_ColorKey_ColorItem; +pub extern fn map_ColorKey_ColorItem_free(map: [*c]Map_ColorKey_ColorItem) void; +pub extern fn map_ColorKey_ColorItem_destroy(map: [*c]Map_ColorKey_ColorItem) void; +pub extern fn map_ColorKey_ColorItem_get(map: [*c]Map_ColorKey_ColorItem, key: ColorKey) ColorItem; +pub extern fn map_ColorKey_ColorItem_has(map: [*c]Map_ColorKey_ColorItem, key: ColorKey) bool; +pub extern fn map_ColorKey_ColorItem_key(map: [*c]Map_ColorKey_ColorItem, key: ColorKey) ColorKey; +pub extern fn map_ColorKey_ColorItem_put(map: [*c]Map_ColorKey_ColorItem, key: ColorKey, value: ColorItem) ColorItem; +pub extern fn map_ColorKey_ColorItem_ref(map: [*c]Map_ColorKey_ColorItem, key: ColorKey, put: bool) [*c]ColorItem; +pub extern fn map_ColorKey_ColorItem_del(map: [*c]Map_ColorKey_ColorItem, key: ColorKey) ColorItem; +pub extern fn map_ColorKey_ColorItem_clear(map: [*c]Map_ColorKey_ColorItem) void; +pub const kh_KittyKey_cstr_t_map_t = extern struct { + n_buckets: khint_t, + size: khint_t, + n_occupied: khint_t, + upper_bound: khint_t, + flags: [*c]khint32_t, + keys: [*c]KittyKey, + vals: [*c]cstr_t, +}; +pub extern fn kh_init_KittyKey_cstr_t_map() [*c]kh_KittyKey_cstr_t_map_t; +pub extern fn kh_dealloc_KittyKey_cstr_t_map(h: [*c]kh_KittyKey_cstr_t_map_t) void; +pub extern fn kh_destroy_KittyKey_cstr_t_map(h: [*c]kh_KittyKey_cstr_t_map_t) void; +pub extern fn kh_clear_KittyKey_cstr_t_map(h: [*c]kh_KittyKey_cstr_t_map_t) void; +pub extern fn kh_get_KittyKey_cstr_t_map(h: [*c]const kh_KittyKey_cstr_t_map_t, key: KittyKey) khint_t; +pub extern fn kh_resize_KittyKey_cstr_t_map(h: [*c]kh_KittyKey_cstr_t_map_t, new_n_buckets: khint_t) void; +pub extern fn kh_put_KittyKey_cstr_t_map(h: [*c]kh_KittyKey_cstr_t_map_t, key: KittyKey, ret: [*c]c_int) khint_t; +pub extern fn kh_del_KittyKey_cstr_t_map(h: [*c]kh_KittyKey_cstr_t_map_t, x: khint_t) void; +pub const Map_KittyKey_cstr_t = extern struct { + table: kh_KittyKey_cstr_t_map_t, +}; +pub extern fn map_KittyKey_cstr_t_new() [*c]Map_KittyKey_cstr_t; +pub extern fn map_KittyKey_cstr_t_free(map: [*c]Map_KittyKey_cstr_t) void; +pub extern fn map_KittyKey_cstr_t_destroy(map: [*c]Map_KittyKey_cstr_t) void; +pub extern fn map_KittyKey_cstr_t_get(map: [*c]Map_KittyKey_cstr_t, key: KittyKey) cstr_t; +pub extern fn map_KittyKey_cstr_t_has(map: [*c]Map_KittyKey_cstr_t, key: KittyKey) bool; +pub extern fn map_KittyKey_cstr_t_key(map: [*c]Map_KittyKey_cstr_t, key: KittyKey) KittyKey; +pub extern fn map_KittyKey_cstr_t_put(map: [*c]Map_KittyKey_cstr_t, key: KittyKey, value: cstr_t) cstr_t; +pub extern fn map_KittyKey_cstr_t_ref(map: [*c]Map_KittyKey_cstr_t, key: KittyKey, put: bool) [*c]cstr_t; +pub extern fn map_KittyKey_cstr_t_del(map: [*c]Map_KittyKey_cstr_t, key: KittyKey) cstr_t; +pub extern fn map_KittyKey_cstr_t_clear(map: [*c]Map_KittyKey_cstr_t) void; +pub extern fn pmap_del2(map: [*c]Map_cstr_t_ptr_t, key: [*c]const u8) void; +pub extern fn time_init() void; +pub extern fn os_hrtime() u64; +pub extern fn os_now() u64; +pub extern fn os_delay(ms: u64, ignoreinput: bool) void; +pub extern fn os_microdelay(us: u64, ignoreinput: bool) void; +pub extern fn os_localtime_r(noalias clock: [*c]const time_t, noalias result: [*c]struct_tm) [*c]struct_tm; +pub extern fn os_localtime(result: [*c]struct_tm) [*c]struct_tm; +pub extern fn os_ctime_r(noalias clock: [*c]const time_t, noalias result: [*c]u8, result_len: usize, add_newline: bool) [*c]u8; +pub extern fn os_ctime(result: [*c]u8, result_len: usize, add_newline: bool) [*c]u8; +pub extern fn os_strptime(str: [*c]const u8, format: [*c]const u8, tm: [*c]struct_tm) [*c]u8; +pub extern fn os_time() Timestamp; +pub const kMarkMoveSuccess: c_int = 1; +pub const kMarkMoveFailed: c_int = 2; +pub const kMarkSwitchedBuf: c_int = 4; +pub const kMarkChangedCol: c_int = 8; +pub const kMarkChangedLine: c_int = 16; +pub const kMarkChangedCursor: c_int = 32; +pub const kMarkChangedView: c_int = 64; +pub const MarkMoveRes = c_uint; +pub const kMarkBeginLine: c_int = 1; +pub const kMarkContext: c_int = 2; +pub const KMarkNoContext: c_int = 4; +pub const kMarkSetView: c_int = 8; +pub const kMarkJumpList: c_int = 16; +pub const MarkMove = c_uint; +pub const kMarkBufLocal: c_int = 0; +pub const kMarkAll: c_int = 1; +pub const kMarkAllNoResolve: c_int = 2; +pub const MarkGet = c_uint; +pub const mtnode_t = struct_mtnode_s; +pub const struct_mtnode_s = extern struct { + n: i32 align(8), + level: i32, + parent: [*c]mtnode_t, + key: [19]mtkey_t, + pub fn ptr(self: anytype) @import("std").zig.c_translation.FlexibleArrayType(@TypeOf(self), [*c]mtnode_t) { + const Intermediate = @import("std").zig.c_translation.FlexibleArrayType(@TypeOf(self), u8); + const ReturnType = @import("std").zig.c_translation.FlexibleArrayType(@TypeOf(self), [*c]mtnode_t); + return @ptrCast(ReturnType, @alignCast(@alignOf([*c]mtnode_t), @ptrCast(Intermediate, self) + 624)); + } +}; +pub const mtpos_t = extern struct { + row: i32, + col: i32, +}; +const struct_unnamed_55 = extern struct { + oldcol: c_int, + i: c_int, +}; +pub const MarkTreeIter = extern struct { + pos: mtpos_t, + lvl: c_int, + node: [*c]mtnode_t, + i: c_int, + s: [20]struct_unnamed_55, + intersect_idx: usize, + intersect_pos: mtpos_t, +}; +pub const mtkey_t = extern struct { + pos: mtpos_t, + ns: u32, + id: u32, + hl_id: i32, + flags: u16, + priority: u16, + decor_full: [*c]Decoration, +}; +pub fn mt_lookup_id(arg_ns: u32, arg_id: u32, arg_enda: bool) callconv(.C) u64 { + var ns = arg_ns; + var id = arg_id; + var enda = arg_enda; + return ((@bitCast(u64, @as(c_ulong, ns)) << @intCast(@import("std").math.Log2Int(u64), 32)) | @bitCast(u64, @as(c_ulong, id))) | (if (@as(c_int, @boolToInt(enda)) != 0) @bitCast(u64, @as(c_long, @as(c_int, 1))) << @intCast(@import("std").math.Log2Int(u64), 63) else @bitCast(u64, @as(c_long, @as(c_int, 0)))); +} +pub fn mt_lookup_key(arg_key: mtkey_t) callconv(.C) u64 { + var key = arg_key; + return mt_lookup_id(key.ns, key.id, (@bitCast(c_int, @as(c_uint, key.flags)) & (@bitCast(c_int, @as(c_uint, @bitCast(u16, @truncate(c_short, @as(c_int, 1))))) << @intCast(@import("std").math.Log2Int(c_int), 1))) != 0); +} +pub fn mt_paired(arg_key: mtkey_t) callconv(.C) bool { + var key = arg_key; + return (@bitCast(c_int, @as(c_uint, key.flags)) & (@bitCast(c_int, @as(c_uint, @bitCast(u16, @truncate(c_short, @as(c_int, 1))))) << @intCast(@import("std").math.Log2Int(c_int), 2))) != 0; +} +pub fn mt_end(arg_key: mtkey_t) callconv(.C) bool { + var key = arg_key; + return (@bitCast(c_int, @as(c_uint, key.flags)) & (@bitCast(c_int, @as(c_uint, @bitCast(u16, @truncate(c_short, @as(c_int, 1))))) << @intCast(@import("std").math.Log2Int(c_int), 1))) != 0; +} +pub fn mt_start(arg_key: mtkey_t) callconv(.C) bool { + var key = arg_key; + return (@as(c_int, @boolToInt(mt_paired(key))) != 0) and !mt_end(key); +} +pub fn mt_right(arg_key: mtkey_t) callconv(.C) bool { + var key = arg_key; + return (@bitCast(c_int, @as(c_uint, key.flags)) & (@bitCast(c_int, @as(c_uint, @bitCast(u16, @truncate(c_short, @as(c_int, 1))))) << @intCast(@import("std").math.Log2Int(c_int), 14))) != 0; +} +pub fn marktree_decor_level(arg_key: mtkey_t) callconv(.C) u8 { + var key = arg_key; + return @bitCast(u8, @truncate(i8, (@bitCast(c_int, @as(c_uint, key.flags)) & (@bitCast(c_int, @as(c_uint, @bitCast(u16, @truncate(c_short, @as(c_int, 4) - @as(c_int, 1))))) << @intCast(@import("std").math.Log2Int(c_int), 4))) >> @intCast(@import("std").math.Log2Int(c_int), 4))); +} +pub fn mt_flags(arg_right_gravity: bool, arg_decor_level: u8) callconv(.C) u16 { + var right_gravity = arg_right_gravity; + var decor_level = arg_decor_level; + _ = blk: { + _ = @sizeOf(c_int); + break :blk blk_1: { + break :blk_1 if (@bitCast(c_int, @as(c_uint, decor_level)) < @as(c_int, 4)) {} else { + __assert_fail("decor_level < DECOR_LEVELS", "_nvim/src/nvim/marktree.h", @bitCast(c_uint, @as(c_int, 116)), "uint16_t mt_flags(_Bool, uint8_t)"); + }; + }; + }; + return @bitCast(u16, @truncate(c_short, (if (@as(c_int, @boolToInt(right_gravity)) != 0) @bitCast(c_int, @as(c_uint, @bitCast(u16, @truncate(c_short, @as(c_int, 1))))) << @intCast(@import("std").math.Log2Int(c_int), 14) else @as(c_int, 0)) | (@bitCast(c_int, @as(c_uint, decor_level)) << @intCast(@import("std").math.Log2Int(c_int), 4)))); +} +pub const MarkTree = extern struct { + root: [*c]mtnode_t, + n_keys: usize, + n_nodes: usize, + id2node: [1]Map_uint64_t_ptr_t, +}; +pub extern fn marktree_put(b: [*c]MarkTree, key: mtkey_t, end_row: c_int, end_col: c_int, end_right: bool) void; +pub extern fn marktree_put_key(b: [*c]MarkTree, k: mtkey_t) void; +pub extern fn marktree_del_itr(b: [*c]MarkTree, itr: [*c]MarkTreeIter, rev: bool) u64; +pub extern fn marktree_clear(b: [*c]MarkTree) void; +pub extern fn marktree_free_node(x: [*c]mtnode_t) void; +pub extern fn marktree_revise(b: [*c]MarkTree, itr: [*c]MarkTreeIter, decor_level: u8, key: mtkey_t) void; +pub extern fn marktree_move(b: [*c]MarkTree, itr: [*c]MarkTreeIter, row: c_int, col: c_int) void; +pub extern fn marktree_itr_get(b: [*c]MarkTree, row: i32, col: c_int, itr: [*c]MarkTreeIter) bool; +pub extern fn marktree_itr_get_ext(b: [*c]MarkTree, p: mtpos_t, itr: [*c]MarkTreeIter, last: bool, gravity: bool, oldbase: [*c]mtpos_t) bool; +pub extern fn marktree_itr_first(b: [*c]MarkTree, itr: [*c]MarkTreeIter) bool; +pub extern fn marktree_itr_last(b: [*c]MarkTree, itr: [*c]MarkTreeIter) c_int; +pub extern fn marktree_itr_next(b: [*c]MarkTree, itr: [*c]MarkTreeIter) bool; +pub extern fn marktree_itr_prev(b: [*c]MarkTree, itr: [*c]MarkTreeIter) bool; +pub extern fn marktree_itr_rewind(b: [*c]MarkTree, itr: [*c]MarkTreeIter) void; +pub extern fn marktree_itr_node_done(itr: [*c]MarkTreeIter) bool; +pub extern fn marktree_itr_pos(itr: [*c]MarkTreeIter) mtpos_t; +pub extern fn marktree_itr_current(itr: [*c]MarkTreeIter) mtkey_t; +pub extern fn marktree_splice(b: [*c]MarkTree, start_line: i32, start_col: c_int, old_extent_line: c_int, old_extent_col: c_int, new_extent_line: c_int, new_extent_col: c_int) bool; +pub extern fn marktree_move_region(b: [*c]MarkTree, start_row: c_int, start_col: colnr_T, extent_row: c_int, extent_col: colnr_T, new_row: c_int, new_col: colnr_T) void; +pub extern fn marktree_lookup_ns(b: [*c]MarkTree, ns: u32, id: u32, end: bool, itr: [*c]MarkTreeIter) mtkey_t; +pub extern fn marktree_lookup(b: [*c]MarkTree, id: u64, itr: [*c]MarkTreeIter) mtkey_t; +pub extern fn marktree_get_altpos(b: [*c]MarkTree, mark: mtkey_t, itr: [*c]MarkTreeIter) mtpos_t; +pub extern fn marktree_get_alt(b: [*c]MarkTree, mark: mtkey_t, itr: [*c]MarkTreeIter) mtkey_t; +pub extern fn marktree_put_test(b: [*c]MarkTree, id: u32, row: c_int, col: c_int, right_gravity: bool) void; +pub extern fn mt_right_test(key: mtkey_t) bool; +pub extern fn marktree_check(b: [*c]MarkTree) void; +pub extern fn marktree_check_node(b: [*c]MarkTree, x: [*c]mtnode_t, last: [*c]mtpos_t, last_right: [*c]bool) usize; +pub extern fn mt_inspect_rec(b: [*c]MarkTree) [*c]u8; +pub extern fn mt_inspect_node(b: [*c]MarkTree, ga: [*c]garray_T, n: [*c]mtnode_t, off: mtpos_t) void; +pub const OPT_FREE: c_int = 1; +pub const OPT_GLOBAL: c_int = 2; +pub const OPT_LOCAL: c_int = 4; +pub const OPT_MODELINE: c_int = 8; +pub const OPT_WINONLY: c_int = 16; +pub const OPT_NOWIN: c_int = 32; +pub const OPT_ONECOLUMN: c_int = 64; +pub const OPT_NO_REDRAW: c_int = 128; +pub const OPT_SKIPRTP: c_int = 256; +pub const OPT_CLEAR: c_int = 512; +pub const OptionFlags = c_uint; +pub const SHM_RO: c_int = 114; +pub const SHM_MOD: c_int = 109; +pub const SHM_FILE: c_int = 102; +pub const SHM_LAST: c_int = 105; +pub const SHM_TEXT: c_int = 120; +pub const SHM_LINES: c_int = 108; +pub const SHM_NEW: c_int = 110; +pub const SHM_WRI: c_int = 119; +pub const SHM_ABBREVIATIONS: c_int = 97; +pub const SHM_WRITE: c_int = 87; +pub const SHM_TRUNC: c_int = 116; +pub const SHM_TRUNCALL: c_int = 84; +pub const SHM_OVER: c_int = 111; +pub const SHM_OVERALL: c_int = 79; +pub const SHM_SEARCH: c_int = 115; +pub const SHM_ATTENTION: c_int = 65; +pub const SHM_INTRO: c_int = 73; +pub const SHM_COMPLETIONMENU: c_int = 99; +pub const SHM_COMPLETIONSCAN: c_int = 67; +pub const SHM_RECORDING: c_int = 113; +pub const SHM_FILEINFO: c_int = 70; +pub const SHM_SEARCHCOUNT: c_int = 83; +pub const SHM_LEN: c_int = 30; +const enum_unnamed_56 = c_uint; +pub const STL_FILEPATH: c_int = 102; +pub const STL_FULLPATH: c_int = 70; +pub const STL_FILENAME: c_int = 116; +pub const STL_COLUMN: c_int = 99; +pub const STL_VIRTCOL: c_int = 118; +pub const STL_VIRTCOL_ALT: c_int = 86; +pub const STL_LINE: c_int = 108; +pub const STL_NUMLINES: c_int = 76; +pub const STL_BUFNO: c_int = 110; +pub const STL_KEYMAP: c_int = 107; +pub const STL_OFFSET: c_int = 111; +pub const STL_OFFSET_X: c_int = 79; +pub const STL_BYTEVAL: c_int = 98; +pub const STL_BYTEVAL_X: c_int = 66; +pub const STL_ROFLAG: c_int = 114; +pub const STL_ROFLAG_ALT: c_int = 82; +pub const STL_HELPFLAG: c_int = 104; +pub const STL_HELPFLAG_ALT: c_int = 72; +pub const STL_FILETYPE: c_int = 121; +pub const STL_FILETYPE_ALT: c_int = 89; +pub const STL_PREVIEWFLAG: c_int = 119; +pub const STL_PREVIEWFLAG_ALT: c_int = 87; +pub const STL_MODIFIED: c_int = 109; +pub const STL_MODIFIED_ALT: c_int = 77; +pub const STL_QUICKFIX: c_int = 113; +pub const STL_PERCENTAGE: c_int = 112; +pub const STL_ALTPERCENT: c_int = 80; +pub const STL_ARGLISTSTAT: c_int = 97; +pub const STL_PAGENUM: c_int = 78; +pub const STL_SHOWCMD: c_int = 83; +pub const STL_FOLDCOL: c_int = 67; +pub const STL_SIGNCOL: c_int = 115; +pub const STL_VIM_EXPR: c_int = 123; +pub const STL_SEPARATE: c_int = 61; +pub const STL_TRUNCMARK: c_int = 60; +pub const STL_USER_HL: c_int = 42; +pub const STL_HIGHLIGHT: c_int = 35; +pub const STL_TABPAGENR: c_int = 84; +pub const STL_TABCLOSENR: c_int = 88; +pub const STL_CLICK_FUNC: c_int = 64; +const enum_unnamed_57 = c_uint; +pub extern var p_ambw: [*c]u8; +pub extern var p_acd: c_int; +pub extern var p_ai: c_int; +pub extern var p_bin: c_int; +pub extern var p_bomb: c_int; +pub extern var p_bl: c_int; +pub extern var p_cin: c_int; +pub extern var p_channel: c_long; +pub extern var p_cink: [*c]u8; +pub extern var p_cinsd: [*c]u8; +pub extern var p_cinw: [*c]u8; +pub extern var p_cfu: [*c]u8; +pub extern var p_ofu: [*c]u8; +pub extern var p_tsrfu: [*c]u8; +pub extern var p_ci: c_int; +pub extern var p_ar: c_int; +pub extern var p_aw: c_int; +pub extern var p_awa: c_int; +pub extern var p_bs: [*c]u8; +pub extern var p_bg: [*c]u8; +pub extern var p_bk: c_int; +pub extern var p_bkc: [*c]u8; +pub extern var bkc_flags: c_uint; +pub extern var p_bdir: [*c]u8; +pub extern var p_bex: [*c]u8; +pub extern var p_bo: [*c]u8; +pub extern var breakat_flags: [256]u8; +pub extern var bo_flags: c_uint; +pub extern var p_bsk: [*c]u8; +pub extern var p_breakat: [*c]u8; +pub extern var p_bh: [*c]u8; +pub extern var p_bt: [*c]u8; +pub extern var p_cmp: [*c]u8; +pub extern var cmp_flags: c_uint; +pub extern var p_enc: [*c]u8; +pub extern var p_deco: c_int; +pub extern var p_ccv: [*c]u8; +pub extern var p_cino: [*c]u8; +pub extern var p_cedit: [*c]u8; +pub extern var p_cb: [*c]u8; +pub extern var cb_flags: c_uint; +pub extern var p_cwh: c_long; +pub extern var p_ch: c_long; +pub extern var p_cms: [*c]u8; +pub extern var p_cpt: [*c]u8; +pub extern var p_columns: c_long; +pub extern var p_confirm: c_int; +pub extern var p_cot: [*c]u8; +pub extern var p_pb: c_long; +pub extern var p_ph: c_long; +pub extern var p_pw: c_long; +pub extern var p_com: [*c]u8; +pub extern var p_cpo: [*c]u8; +pub extern var p_debug: [*c]u8; +pub extern var p_def: [*c]u8; +pub extern var p_inc: [*c]u8; +pub extern var p_dip: [*c]u8; +pub extern var p_dex: [*c]u8; +pub extern var p_dict: [*c]u8; +pub extern var p_dg: c_int; +pub extern var p_dir: [*c]u8; +pub extern var p_dy: [*c]u8; +pub extern var dy_flags: c_uint; +pub extern var p_ed: c_int; +pub extern var p_ead: [*c]u8; +pub extern var p_emoji: c_int; +pub extern var p_ea: c_int; +pub extern var p_ep: [*c]u8; +pub extern var p_eb: c_int; +pub extern var p_ef: [*c]u8; +pub extern var p_efm: [*c]u8; +pub extern var p_gefm: [*c]u8; +pub extern var p_gp: [*c]u8; +pub extern var p_eof: c_int; +pub extern var p_eol: c_int; +pub extern var p_ei: [*c]u8; +pub extern var p_et: c_int; +pub extern var p_exrc: c_int; +pub extern var p_fenc: [*c]u8; +pub extern var p_fencs: [*c]u8; +pub extern var p_ff: [*c]u8; +pub extern var p_ffs: [*c]u8; +pub extern var p_fic: c_int; +pub extern var p_ft: [*c]u8; +pub extern var p_fcs: [*c]u8; +pub extern var p_fixeol: c_int; +pub extern var p_fcl: [*c]u8; +pub extern var p_fdls: c_long; +pub extern var p_fdo: [*c]u8; +pub extern var fdo_flags: c_uint; +pub extern var p_fex: [*c]u8; +pub extern var p_flp: [*c]u8; +pub extern var p_fo: [*c]u8; +pub extern var p_fp: [*c]u8; +pub extern var p_fs: c_int; +pub extern var p_gd: c_int; +pub extern var p_guicursor: [*c]u8; +pub extern var p_guifont: [*c]u8; +pub extern var p_guifontwide: [*c]u8; +pub extern var p_hf: [*c]u8; +pub extern var p_hh: c_long; +pub extern var p_hlg: [*c]u8; +pub extern var p_hid: c_int; +pub extern var p_hl: [*c]u8; +pub extern var p_hls: c_int; +pub extern var p_hi: c_long; +pub extern var p_arshape: c_int; +pub extern var p_icon: c_int; +pub extern var p_iconstring: [*c]u8; +pub extern var p_ic: c_int; +pub extern var p_iminsert: c_long; +pub extern var p_imsearch: c_long; +pub extern var p_inf: c_int; +pub extern var p_inex: [*c]u8; +pub extern var p_is: c_int; +pub extern var p_inde: [*c]u8; +pub extern var p_indk: [*c]u8; +pub extern var p_icm: [*c]u8; +pub extern var p_isf: [*c]u8; +pub extern var p_isi: [*c]u8; +pub extern var p_isk: [*c]u8; +pub extern var p_isp: [*c]u8; +pub extern var p_js: c_int; +pub extern var p_jop: [*c]u8; +pub extern var jop_flags: c_uint; +pub extern var p_keymap: [*c]u8; +pub extern var p_kp: [*c]u8; +pub extern var p_km: [*c]u8; +pub extern var p_langmap: [*c]u8; +pub extern var p_lnr: c_int; +pub extern var p_lrm: c_int; +pub extern var p_lm: [*c]u8; +pub extern var p_lines: c_long; +pub extern var p_linespace: c_long; +pub extern var p_lisp: c_int; +pub extern var p_lop: [*c]u8; +pub extern var p_lispwords: [*c]u8; +pub extern var p_ls: c_long; +pub extern var p_stal: c_long; +pub extern var p_lcs: [*c]u8; +pub extern var p_lz: c_int; +pub extern var p_lpl: c_int; +pub extern var p_magic: c_int; +pub extern var p_menc: [*c]u8; +pub extern var p_mef: [*c]u8; +pub extern var p_mp: [*c]u8; +pub extern var p_mps: [*c]u8; +pub extern var p_mat: c_long; +pub extern var p_mco: c_long; +pub extern var p_mfd: c_long; +pub extern var p_mmd: c_long; +pub extern var p_mmp: c_long; +pub extern var p_mis: c_long; +pub extern var p_msm: [*c]u8; +pub extern var p_ml: c_int; +pub extern var p_mle: c_int; +pub extern var p_mls: c_long; +pub extern var p_ma: c_int; +pub extern var p_mod: c_int; +pub extern var p_mouse: [*c]u8; +pub extern var p_mousem: [*c]u8; +pub extern var p_mousemev: c_int; +pub extern var p_mousef: c_int; +pub extern var p_mousescroll: [*c]u8; +pub extern var p_mousescroll_vert: c_long; +pub extern var p_mousescroll_hor: c_long; +pub extern var p_mouset: c_long; +pub extern var p_more: c_int; +pub extern var p_nf: [*c]u8; +pub extern var p_opfunc: [*c]u8; +pub extern var p_para: [*c]u8; +pub extern var p_paste: c_int; +pub extern var p_pex: [*c]u8; +pub extern var p_pm: [*c]u8; +pub extern var p_path: [*c]u8; +pub extern var p_cdpath: [*c]u8; +pub extern var p_pi: c_int; +pub extern var p_pyx: c_long; +pub extern var p_qe: [*c]u8; +pub extern var p_ro: c_int; +pub extern var p_rdb: [*c]u8; +pub extern var rdb_flags: c_uint; +pub extern var p_rdt: c_long; +pub extern var p_re: c_long; +pub extern var p_report: c_long; +pub extern var p_pvh: c_long; +pub extern var p_ari: c_int; +pub extern var p_ri: c_int; +pub extern var p_ru: c_int; +pub extern var p_ruf: [*c]u8; +pub extern var p_pp: [*c]u8; +pub extern var p_qftf: [*c]u8; +pub extern var p_rtp: [*c]u8; +pub extern var p_scbk: c_long; +pub extern var p_sj: c_long; +pub extern var p_so: c_long; +pub extern var p_sbo: [*c]u8; +pub extern var p_sections: [*c]u8; +pub extern var p_secure: c_int; +pub extern var p_sel: [*c]u8; +pub extern var p_slm: [*c]u8; +pub extern var p_ssop: [*c]u8; +pub extern var ssop_flags: c_uint; +pub extern var p_sh: [*c]u8; +pub extern var p_shcf: [*c]u8; +pub extern var p_sp: [*c]u8; +pub extern var p_shq: [*c]u8; +pub extern var p_sxq: [*c]u8; +pub extern var p_sxe: [*c]u8; +pub extern var p_srr: [*c]u8; +pub extern var p_stmp: c_int; +pub extern var p_stl: [*c]u8; +pub extern var p_wbr: [*c]u8; +pub extern var p_sr: c_int; +pub extern var p_sw: c_long; +pub extern var p_shm: [*c]u8; +pub extern var p_sbr: [*c]u8; +pub extern var p_sc: c_int; +pub extern var p_sloc: [*c]u8; +pub extern var p_sft: c_int; +pub extern var p_sm: c_int; +pub extern var p_smd: c_int; +pub extern var p_ss: c_long; +pub extern var p_siso: c_long; +pub extern var p_scs: c_int; +pub extern var p_si: c_int; +pub extern var p_sta: c_int; +pub extern var p_sts: c_long; +pub extern var p_sb: c_int; +pub extern var p_sua: [*c]u8; +pub extern var p_swf: c_int; +pub extern var p_smc: c_long; +pub extern var p_tpm: c_long; +pub extern var p_tal: [*c]u8; +pub extern var p_tpf: [*c]u8; +pub extern var tpf_flags: c_uint; +pub extern var p_tfu: [*c]u8; +pub extern var p_spc: [*c]u8; +pub extern var p_spf: [*c]u8; +pub extern var p_spk: [*c]u8; +pub extern var p_spl: [*c]u8; +pub extern var p_spo: [*c]u8; +pub extern var spo_flags: c_uint; +pub extern var p_sps: [*c]u8; +pub extern var p_spr: c_int; +pub extern var p_sol: c_int; +pub extern var p_su: [*c]u8; +pub extern var p_swb: [*c]u8; +pub extern var swb_flags: c_uint; +pub extern var p_syn: [*c]u8; +pub extern var p_ts: c_long; +pub extern var p_tbs: c_int; +pub extern var p_tc: [*c]u8; +pub extern var tc_flags: c_uint; +pub extern var p_tl: c_long; +pub extern var p_tr: c_int; +pub extern var p_tags: [*c]u8; +pub extern var p_tgst: c_int; +pub extern var p_tbidi: c_int; +pub extern var p_tw: c_long; +pub extern var p_to: c_int; +pub extern var p_timeout: c_int; +pub extern var p_tm: c_long; +pub extern var p_title: c_int; +pub extern var p_titlelen: c_long; +pub extern var p_titleold: [*c]u8; +pub extern var p_titlestring: [*c]u8; +pub extern var p_tsr: [*c]u8; +pub extern var p_tgc: c_int; +pub extern var p_ttimeout: c_int; +pub extern var p_ttm: c_long; +pub extern var p_udir: [*c]u8; +pub extern var p_udf: c_int; +pub extern var p_ul: c_long; +pub extern var p_ur: c_long; +pub extern var p_uc: c_long; +pub extern var p_ut: c_long; +pub extern var p_shada: [*c]u8; +pub extern var p_shadafile: [*c]u8; +pub extern var p_vsts: [*c]u8; +pub extern var p_vts: [*c]u8; +pub extern var p_vdir: [*c]u8; +pub extern var p_vop: [*c]u8; +pub extern var vop_flags: c_uint; +pub extern var p_vb: c_int; +pub extern var p_ve: [*c]u8; +pub extern var ve_flags: c_uint; +pub extern var p_verbose: c_long; +pub extern var p_vfile: [*c]u8; +pub extern var p_warn: c_int; +pub extern var p_wop: [*c]u8; +pub extern var wop_flags: c_uint; +pub extern var p_window: c_long; +pub extern var p_wak: [*c]u8; +pub extern var p_wig: [*c]u8; +pub extern var p_ww: [*c]u8; +pub extern var p_wc: c_long; +pub extern var p_wcm: c_long; +pub extern var p_wic: c_int; +pub extern var p_wim: [*c]u8; +pub extern var p_wmnu: c_int; +pub extern var p_wh: c_long; +pub extern var p_wmh: c_long; +pub extern var p_wmw: c_long; +pub extern var p_wiw: c_long; +pub extern var p_wm: c_long; +pub extern var p_ws: c_int; +pub extern var p_write: c_int; +pub extern var p_wa: c_int; +pub extern var p_wb: c_int; +pub extern var p_wd: c_long; +pub extern var p_cdh: c_int; +pub extern var p_force_on: c_int; +pub extern var p_force_off: c_int; +pub const BV_AI: c_int = 0; +pub const BV_AR: c_int = 1; +pub const BV_BH: c_int = 2; +pub const BV_BKC: c_int = 3; +pub const BV_BT: c_int = 4; +pub const BV_EFM: c_int = 5; +pub const BV_GP: c_int = 6; +pub const BV_MP: c_int = 7; +pub const BV_BIN: c_int = 8; +pub const BV_BL: c_int = 9; +pub const BV_BOMB: c_int = 10; +pub const BV_CHANNEL: c_int = 11; +pub const BV_CI: c_int = 12; +pub const BV_CIN: c_int = 13; +pub const BV_CINK: c_int = 14; +pub const BV_CINO: c_int = 15; +pub const BV_CINW: c_int = 16; +pub const BV_CINSD: c_int = 17; +pub const BV_CM: c_int = 18; +pub const BV_CMS: c_int = 19; +pub const BV_COM: c_int = 20; +pub const BV_CPT: c_int = 21; +pub const BV_DICT: c_int = 22; +pub const BV_TSR: c_int = 23; +pub const BV_CSL: c_int = 24; +pub const BV_CFU: c_int = 25; +pub const BV_DEF: c_int = 26; +pub const BV_INC: c_int = 27; +pub const BV_EOF: c_int = 28; +pub const BV_EOL: c_int = 29; +pub const BV_FIXEOL: c_int = 30; +pub const BV_EP: c_int = 31; +pub const BV_ET: c_int = 32; +pub const BV_FENC: c_int = 33; +pub const BV_FP: c_int = 34; +pub const BV_BEXPR: c_int = 35; +pub const BV_FEX: c_int = 36; +pub const BV_FF: c_int = 37; +pub const BV_FLP: c_int = 38; +pub const BV_FO: c_int = 39; +pub const BV_FT: c_int = 40; +pub const BV_IMI: c_int = 41; +pub const BV_IMS: c_int = 42; +pub const BV_INDE: c_int = 43; +pub const BV_INDK: c_int = 44; +pub const BV_INEX: c_int = 45; +pub const BV_INF: c_int = 46; +pub const BV_ISK: c_int = 47; +pub const BV_KMAP: c_int = 48; +pub const BV_KP: c_int = 49; +pub const BV_LISP: c_int = 50; +pub const BV_LOP: c_int = 51; +pub const BV_LW: c_int = 52; +pub const BV_MENC: c_int = 53; +pub const BV_MA: c_int = 54; +pub const BV_ML: c_int = 55; +pub const BV_MOD: c_int = 56; +pub const BV_MPS: c_int = 57; +pub const BV_NF: c_int = 58; +pub const BV_OFU: c_int = 59; +pub const BV_PATH: c_int = 60; +pub const BV_PI: c_int = 61; +pub const BV_QE: c_int = 62; +pub const BV_RO: c_int = 63; +pub const BV_SCBK: c_int = 64; +pub const BV_SI: c_int = 65; +pub const BV_SMC: c_int = 66; +pub const BV_SYN: c_int = 67; +pub const BV_SPC: c_int = 68; +pub const BV_SPF: c_int = 69; +pub const BV_SPL: c_int = 70; +pub const BV_SPO: c_int = 71; +pub const BV_STS: c_int = 72; +pub const BV_SUA: c_int = 73; +pub const BV_SW: c_int = 74; +pub const BV_SWF: c_int = 75; +pub const BV_TFU: c_int = 76; +pub const BV_TSRFU: c_int = 77; +pub const BV_TAGS: c_int = 78; +pub const BV_TC: c_int = 79; +pub const BV_TS: c_int = 80; +pub const BV_TW: c_int = 81; +pub const BV_TX: c_int = 82; +pub const BV_UDF: c_int = 83; +pub const BV_UL: c_int = 84; +pub const BV_WM: c_int = 85; +pub const BV_VSTS: c_int = 86; +pub const BV_VTS: c_int = 87; +pub const BV_COUNT: c_int = 88; +const enum_unnamed_58 = c_uint; +pub const WV_LIST: c_int = 0; +pub const WV_ARAB: c_int = 1; +pub const WV_COCU: c_int = 2; +pub const WV_COLE: c_int = 3; +pub const WV_CRBIND: c_int = 4; +pub const WV_BRI: c_int = 5; +pub const WV_BRIOPT: c_int = 6; +pub const WV_DIFF: c_int = 7; +pub const WV_FDC: c_int = 8; +pub const WV_FEN: c_int = 9; +pub const WV_FDI: c_int = 10; +pub const WV_FDL: c_int = 11; +pub const WV_FDM: c_int = 12; +pub const WV_FML: c_int = 13; +pub const WV_FDN: c_int = 14; +pub const WV_FDE: c_int = 15; +pub const WV_FDT: c_int = 16; +pub const WV_FMR: c_int = 17; +pub const WV_LBR: c_int = 18; +pub const WV_NU: c_int = 19; +pub const WV_RNU: c_int = 20; +pub const WV_VE: c_int = 21; +pub const WV_NUW: c_int = 22; +pub const WV_PVW: c_int = 23; +pub const WV_RL: c_int = 24; +pub const WV_RLC: c_int = 25; +pub const WV_SCBIND: c_int = 26; +pub const WV_SCROLL: c_int = 27; +pub const WV_SISO: c_int = 28; +pub const WV_SO: c_int = 29; +pub const WV_SPELL: c_int = 30; +pub const WV_CUC: c_int = 31; +pub const WV_CUL: c_int = 32; +pub const WV_CULOPT: c_int = 33; +pub const WV_CC: c_int = 34; +pub const WV_SBR: c_int = 35; +pub const WV_STC: c_int = 36; +pub const WV_STL: c_int = 37; +pub const WV_WFH: c_int = 38; +pub const WV_WFW: c_int = 39; +pub const WV_WRAP: c_int = 40; +pub const WV_SCL: c_int = 41; +pub const WV_WINHL: c_int = 42; +pub const WV_LCS: c_int = 43; +pub const WV_FCS: c_int = 44; +pub const WV_WINBL: c_int = 45; +pub const WV_WBR: c_int = 46; +pub const WV_COUNT: c_int = 47; +const enum_unnamed_59 = c_uint; +pub const LastSet = extern struct { + script_ctx: sctx_T, + channel_id: u64, +}; +pub const PV_NONE: c_int = 0; +pub const PV_MAXVAL: c_int = 65535; +pub const idopt_T = c_uint; +pub const struct_vimoption = extern struct { + fullname: [*c]u8, + shortname: [*c]u8, + flags: u32, + @"var": [*c]u8, + indir: idopt_T, + def_val: [*c]u8, + last_set: LastSet, +}; +pub const vimoption_T = struct_vimoption; +pub const struct_foldinfo = extern struct { + fi_lnum: linenr_T, + fi_level: c_int, + fi_low_level: c_int, + fi_lines: linenr_T, +}; +pub const foldinfo_T = struct_foldinfo; +pub const SignTextAttrs = extern struct { + text: [*c]u8, + hl_id: c_int, + priority: c_int, +}; +pub const SIGN_LINEHL: c_int = 0; +pub const SIGN_NUMHL: c_int = 1; +pub const SIGN_TEXT: c_int = 2; +pub const SignType = c_uint; +pub const kStlClickDisabled: c_int = 0; +pub const kStlClickTabSwitch: c_int = 1; +pub const kStlClickTabClose: c_int = 2; +pub const kStlClickFuncRun: c_int = 3; +const enum_unnamed_60 = c_uint; +pub const StlClickDefinition = extern struct { + type: enum_unnamed_60, + tabnr: c_int, + func: [*c]u8, +}; +pub const StlClickRecord = extern struct { + def: StlClickDefinition, + start: [*c]const u8, +}; +pub const struct_stl_hlrec = extern struct { + start: [*c]u8, + userhl: c_int, +}; +pub const stl_hlrec_t = struct_stl_hlrec; +pub const Normal: c_int = 0; +pub const Empty: c_int = 1; +pub const Group: c_int = 2; +pub const Separate: c_int = 3; +pub const Highlight: c_int = 4; +pub const TabPage: c_int = 5; +pub const ClickFunc: c_int = 6; +pub const Trunc: c_int = 7; +const enum_unnamed_61 = c_uint; +pub const struct_stl_item = extern struct { + start: [*c]u8, + cmd: [*c]u8, + minwid: c_int, + maxwid: c_int, + type: enum_unnamed_61, +}; +pub const stl_item_t = struct_stl_item; +pub const struct_statuscol = extern struct { + width: c_int, + cur_attr: c_int, + num_attr: c_int, + sign_cul_id: c_int, + truncate: c_int, + draw: bool, + use_cul: bool, + text: [4096]u8, + textp: [*c]u8, + text_end: [*c]u8, + hlrec: [*c]stl_hlrec_t, + hlrecp: [*c]stl_hlrec_t, + foldinfo: foldinfo_T, + sattrs: [*c]SignTextAttrs, +}; +pub const statuscol_T = struct_statuscol; +pub const visualinfo_T = extern struct { + vi_start: pos_T, + vi_end: pos_T, + vi_mode: c_int, + vi_curswant: colnr_T, +}; +pub const struct_mf_blocknr_trans_item = extern struct { + nt_hashitem: mf_hashitem_T, + nt_new_bnum: blocknr_T, +}; +pub const mf_blocknr_trans_item_T = struct_mf_blocknr_trans_item; +pub const struct_flock = extern struct { + l_type: c_short, + l_whence: c_short, + l_start: __off_t, + l_len: __off_t, + l_pid: __pid_t, +}; +pub extern fn fcntl(__fd: c_int, __cmd: c_int, ...) c_int; +pub extern fn open(__file: [*c]const u8, __oflag: c_int, ...) c_int; +pub extern fn openat(__fd: c_int, __file: [*c]const u8, __oflag: c_int, ...) c_int; +pub extern fn creat(__file: [*c]const u8, __mode: mode_t) c_int; +pub extern fn posix_fadvise(__fd: c_int, __offset: off_t, __len: off_t, __advise: c_int) c_int; +pub extern fn posix_fallocate(__fd: c_int, __offset: off_t, __len: off_t) c_int; +pub const struct_dirent = extern struct { + d_ino: __ino_t, + d_off: __off_t, + d_reclen: c_ushort, + d_type: u8, + d_name: [256]u8, +}; +pub const DT_UNKNOWN: c_int = 0; +pub const DT_FIFO: c_int = 1; +pub const DT_CHR: c_int = 2; +pub const DT_DIR: c_int = 4; +pub const DT_BLK: c_int = 6; +pub const DT_REG: c_int = 8; +pub const DT_LNK: c_int = 10; +pub const DT_SOCK: c_int = 12; +pub const DT_WHT: c_int = 14; +const enum_unnamed_62 = c_uint; +pub const struct___dirstream = opaque {}; +pub const DIR = struct___dirstream; +pub extern fn closedir(__dirp: ?*DIR) c_int; +pub extern fn opendir(__name: [*c]const u8) ?*DIR; +pub extern fn fdopendir(__fd: c_int) ?*DIR; +pub extern fn readdir(__dirp: ?*DIR) [*c]struct_dirent; +pub extern fn readdir_r(noalias __dirp: ?*DIR, noalias __entry: [*c]struct_dirent, noalias __result: [*c][*c]struct_dirent) c_int; +pub extern fn rewinddir(__dirp: ?*DIR) void; +pub extern fn seekdir(__dirp: ?*DIR, __pos: c_long) void; +pub extern fn telldir(__dirp: ?*DIR) c_long; +pub extern fn dirfd(__dirp: ?*DIR) c_int; +pub extern fn scandir(noalias __dir: [*c]const u8, noalias __namelist: [*c][*c][*c]struct_dirent, __selector: ?*const fn ([*c]const struct_dirent) callconv(.C) c_int, __cmp: ?*const fn ([*c][*c]const struct_dirent, [*c][*c]const struct_dirent) callconv(.C) c_int) c_int; +pub extern fn alphasort(__e1: [*c][*c]const struct_dirent, __e2: [*c][*c]const struct_dirent) c_int; +pub extern fn getdirentries(__fd: c_int, noalias __buf: [*c]u8, __nbytes: usize, noalias __basep: [*c]__off_t) __ssize_t; +pub const struct_iovec = extern struct { + iov_base: ?*anyopaque, + iov_len: usize, +}; +pub const SOCK_STREAM: c_int = 1; +pub const SOCK_DGRAM: c_int = 2; +pub const SOCK_RAW: c_int = 3; +pub const SOCK_RDM: c_int = 4; +pub const SOCK_SEQPACKET: c_int = 5; +pub const SOCK_DCCP: c_int = 6; +pub const SOCK_PACKET: c_int = 10; +pub const SOCK_CLOEXEC: c_int = 524288; +pub const SOCK_NONBLOCK: c_int = 2048; +pub const enum___socket_type = c_uint; +pub const sa_family_t = c_ushort; +pub const struct_sockaddr = extern struct { + sa_family: sa_family_t, + sa_data: [14]u8, +}; +pub const struct_sockaddr_storage = extern struct { + ss_family: sa_family_t, + __ss_padding: [118]u8, + __ss_align: c_ulong, +}; +pub const MSG_OOB: c_int = 1; +pub const MSG_PEEK: c_int = 2; +pub const MSG_DONTROUTE: c_int = 4; +pub const MSG_CTRUNC: c_int = 8; +pub const MSG_PROXY: c_int = 16; +pub const MSG_TRUNC: c_int = 32; +pub const MSG_DONTWAIT: c_int = 64; +pub const MSG_EOR: c_int = 128; +pub const MSG_WAITALL: c_int = 256; +pub const MSG_FIN: c_int = 512; +pub const MSG_SYN: c_int = 1024; +pub const MSG_CONFIRM: c_int = 2048; +pub const MSG_RST: c_int = 4096; +pub const MSG_ERRQUEUE: c_int = 8192; +pub const MSG_NOSIGNAL: c_int = 16384; +pub const MSG_MORE: c_int = 32768; +pub const MSG_WAITFORONE: c_int = 65536; +pub const MSG_BATCH: c_int = 262144; +pub const MSG_ZEROCOPY: c_int = 67108864; +pub const MSG_FASTOPEN: c_int = 536870912; +pub const MSG_CMSG_CLOEXEC: c_int = 1073741824; +const enum_unnamed_63 = c_uint; +pub const struct_msghdr = extern struct { + msg_name: ?*anyopaque, + msg_namelen: socklen_t, + msg_iov: [*c]struct_iovec, + msg_iovlen: usize, + msg_control: ?*anyopaque, + msg_controllen: usize, + msg_flags: c_int, +}; +pub const struct_cmsghdr = extern struct { + cmsg_len: usize align(8), + cmsg_level: c_int, + cmsg_type: c_int, + pub fn __cmsg_data(self: anytype) @import("std").zig.c_translation.FlexibleArrayType(@TypeOf(self), u8) { + const Intermediate = @import("std").zig.c_translation.FlexibleArrayType(@TypeOf(self), u8); + const ReturnType = @import("std").zig.c_translation.FlexibleArrayType(@TypeOf(self), u8); + return @ptrCast(ReturnType, @alignCast(@alignOf(u8), @ptrCast(Intermediate, self) + 16)); + } +}; +pub extern fn __cmsg_nxthdr(__mhdr: [*c]struct_msghdr, __cmsg: [*c]struct_cmsghdr) [*c]struct_cmsghdr; +pub const SCM_RIGHTS: c_int = 1; +const enum_unnamed_64 = c_uint; +pub const __kernel_fd_set = extern struct { + fds_bits: [16]c_ulong, +}; +pub const __kernel_sighandler_t = ?*const fn (c_int) callconv(.C) void; +pub const __kernel_key_t = c_int; +pub const __kernel_mqd_t = c_int; +pub const __kernel_old_uid_t = c_ushort; +pub const __kernel_old_gid_t = c_ushort; +pub const __kernel_old_dev_t = c_ulong; +pub const __kernel_long_t = c_long; +pub const __kernel_ulong_t = c_ulong; +pub const __kernel_ino_t = __kernel_ulong_t; +pub const __kernel_mode_t = c_uint; +pub const __kernel_pid_t = c_int; +pub const __kernel_ipc_pid_t = c_int; +pub const __kernel_uid_t = c_uint; +pub const __kernel_gid_t = c_uint; +pub const __kernel_suseconds_t = __kernel_long_t; +pub const __kernel_daddr_t = c_int; +pub const __kernel_uid32_t = c_uint; +pub const __kernel_gid32_t = c_uint; +pub const __kernel_size_t = __kernel_ulong_t; +pub const __kernel_ssize_t = __kernel_long_t; +pub const __kernel_ptrdiff_t = __kernel_long_t; +pub const __kernel_fsid_t = extern struct { + val: [2]c_int, +}; +pub const __kernel_off_t = __kernel_long_t; +pub const __kernel_loff_t = c_longlong; +pub const __kernel_old_time_t = __kernel_long_t; +pub const __kernel_time_t = __kernel_long_t; +pub const __kernel_time64_t = c_longlong; +pub const __kernel_clock_t = __kernel_long_t; +pub const __kernel_timer_t = c_int; +pub const __kernel_clockid_t = c_int; +pub const __kernel_caddr_t = [*c]u8; +pub const __kernel_uid16_t = c_ushort; +pub const __kernel_gid16_t = c_ushort; +pub const struct_linger = extern struct { + l_onoff: c_int, + l_linger: c_int, +}; +pub const struct_osockaddr = extern struct { + sa_family: c_ushort, + sa_data: [14]u8, +}; +pub const SHUT_RD: c_int = 0; +pub const SHUT_WR: c_int = 1; +pub const SHUT_RDWR: c_int = 2; +const enum_unnamed_65 = c_uint; +pub extern fn socket(__domain: c_int, __type: c_int, __protocol: c_int) c_int; +pub extern fn socketpair(__domain: c_int, __type: c_int, __protocol: c_int, __fds: [*c]c_int) c_int; +pub extern fn bind(__fd: c_int, __addr: [*c]const struct_sockaddr, __len: socklen_t) c_int; +pub extern fn getsockname(__fd: c_int, noalias __addr: [*c]struct_sockaddr, noalias __len: [*c]socklen_t) c_int; +pub extern fn connect(__fd: c_int, __addr: [*c]const struct_sockaddr, __len: socklen_t) c_int; +pub extern fn getpeername(__fd: c_int, noalias __addr: [*c]struct_sockaddr, noalias __len: [*c]socklen_t) c_int; +pub extern fn send(__fd: c_int, __buf: ?*const anyopaque, __n: usize, __flags: c_int) isize; +pub extern fn recv(__fd: c_int, __buf: ?*anyopaque, __n: usize, __flags: c_int) isize; +pub extern fn sendto(__fd: c_int, __buf: ?*const anyopaque, __n: usize, __flags: c_int, __addr: [*c]const struct_sockaddr, __addr_len: socklen_t) isize; +pub extern fn recvfrom(__fd: c_int, noalias __buf: ?*anyopaque, __n: usize, __flags: c_int, noalias __addr: [*c]struct_sockaddr, noalias __addr_len: [*c]socklen_t) isize; +pub extern fn sendmsg(__fd: c_int, __message: [*c]const struct_msghdr, __flags: c_int) isize; +pub extern fn recvmsg(__fd: c_int, __message: [*c]struct_msghdr, __flags: c_int) isize; +pub extern fn getsockopt(__fd: c_int, __level: c_int, __optname: c_int, noalias __optval: ?*anyopaque, noalias __optlen: [*c]socklen_t) c_int; +pub extern fn setsockopt(__fd: c_int, __level: c_int, __optname: c_int, __optval: ?*const anyopaque, __optlen: socklen_t) c_int; +pub extern fn listen(__fd: c_int, __n: c_int) c_int; +pub extern fn accept(__fd: c_int, noalias __addr: [*c]struct_sockaddr, noalias __addr_len: [*c]socklen_t) c_int; +pub extern fn shutdown(__fd: c_int, __how: c_int) c_int; +pub extern fn sockatmark(__fd: c_int) c_int; +pub extern fn isfdtype(__fd: c_int, __fdtype: c_int) c_int; +pub const in_addr_t = u32; +pub const struct_in_addr = extern struct { + s_addr: in_addr_t, +}; +pub const struct_ip_opts = extern struct { + ip_dst: struct_in_addr, + ip_opts: [40]u8, +}; +pub const struct_in_pktinfo = extern struct { + ipi_ifindex: c_int, + ipi_spec_dst: struct_in_addr, + ipi_addr: struct_in_addr, +}; +pub const IPPROTO_IP: c_int = 0; +pub const IPPROTO_ICMP: c_int = 1; +pub const IPPROTO_IGMP: c_int = 2; +pub const IPPROTO_IPIP: c_int = 4; +pub const IPPROTO_TCP: c_int = 6; +pub const IPPROTO_EGP: c_int = 8; +pub const IPPROTO_PUP: c_int = 12; +pub const IPPROTO_UDP: c_int = 17; +pub const IPPROTO_IDP: c_int = 22; +pub const IPPROTO_TP: c_int = 29; +pub const IPPROTO_DCCP: c_int = 33; +pub const IPPROTO_IPV6: c_int = 41; +pub const IPPROTO_RSVP: c_int = 46; +pub const IPPROTO_GRE: c_int = 47; +pub const IPPROTO_ESP: c_int = 50; +pub const IPPROTO_AH: c_int = 51; +pub const IPPROTO_MTP: c_int = 92; +pub const IPPROTO_BEETPH: c_int = 94; +pub const IPPROTO_ENCAP: c_int = 98; +pub const IPPROTO_PIM: c_int = 103; +pub const IPPROTO_COMP: c_int = 108; +pub const IPPROTO_L2TP: c_int = 115; +pub const IPPROTO_SCTP: c_int = 132; +pub const IPPROTO_UDPLITE: c_int = 136; +pub const IPPROTO_MPLS: c_int = 137; +pub const IPPROTO_ETHERNET: c_int = 143; +pub const IPPROTO_RAW: c_int = 255; +pub const IPPROTO_MPTCP: c_int = 262; +pub const IPPROTO_MAX: c_int = 263; +const enum_unnamed_66 = c_uint; +pub const IPPROTO_HOPOPTS: c_int = 0; +pub const IPPROTO_ROUTING: c_int = 43; +pub const IPPROTO_FRAGMENT: c_int = 44; +pub const IPPROTO_ICMPV6: c_int = 58; +pub const IPPROTO_NONE: c_int = 59; +pub const IPPROTO_DSTOPTS: c_int = 60; +pub const IPPROTO_MH: c_int = 135; +const enum_unnamed_67 = c_uint; +pub const in_port_t = u16; +pub const IPPORT_ECHO: c_int = 7; +pub const IPPORT_DISCARD: c_int = 9; +pub const IPPORT_SYSTAT: c_int = 11; +pub const IPPORT_DAYTIME: c_int = 13; +pub const IPPORT_NETSTAT: c_int = 15; +pub const IPPORT_FTP: c_int = 21; +pub const IPPORT_TELNET: c_int = 23; +pub const IPPORT_SMTP: c_int = 25; +pub const IPPORT_TIMESERVER: c_int = 37; +pub const IPPORT_NAMESERVER: c_int = 42; +pub const IPPORT_WHOIS: c_int = 43; +pub const IPPORT_MTP: c_int = 57; +pub const IPPORT_TFTP: c_int = 69; +pub const IPPORT_RJE: c_int = 77; +pub const IPPORT_FINGER: c_int = 79; +pub const IPPORT_TTYLINK: c_int = 87; +pub const IPPORT_SUPDUP: c_int = 95; +pub const IPPORT_EXECSERVER: c_int = 512; +pub const IPPORT_LOGINSERVER: c_int = 513; +pub const IPPORT_CMDSERVER: c_int = 514; +pub const IPPORT_EFSSERVER: c_int = 520; +pub const IPPORT_BIFFUDP: c_int = 512; +pub const IPPORT_WHOSERVER: c_int = 513; +pub const IPPORT_ROUTESERVER: c_int = 520; +pub const IPPORT_RESERVED: c_int = 1024; +pub const IPPORT_USERRESERVED: c_int = 5000; +const enum_unnamed_68 = c_uint; +const union_unnamed_69 = extern union { + __u6_addr8: [16]u8, + __u6_addr16: [8]u16, + __u6_addr32: [4]u32, +}; +pub const struct_in6_addr = extern struct { + __in6_u: union_unnamed_69, +}; +pub extern const in6addr_any: struct_in6_addr; +pub extern const in6addr_loopback: struct_in6_addr; +pub const struct_sockaddr_in = extern struct { + sin_family: sa_family_t, + sin_port: in_port_t, + sin_addr: struct_in_addr, + sin_zero: [8]u8, +}; +pub const struct_sockaddr_in6 = extern struct { + sin6_family: sa_family_t, + sin6_port: in_port_t, + sin6_flowinfo: u32, + sin6_addr: struct_in6_addr, + sin6_scope_id: u32, +}; +pub const struct_ip_mreq = extern struct { + imr_multiaddr: struct_in_addr, + imr_interface: struct_in_addr, +}; +pub const struct_ip_mreqn = extern struct { + imr_multiaddr: struct_in_addr, + imr_address: struct_in_addr, + imr_ifindex: c_int, +}; +pub const struct_ip_mreq_source = extern struct { + imr_multiaddr: struct_in_addr, + imr_interface: struct_in_addr, + imr_sourceaddr: struct_in_addr, +}; +pub const struct_ipv6_mreq = extern struct { + ipv6mr_multiaddr: struct_in6_addr, + ipv6mr_interface: c_uint, +}; +pub const struct_group_req = extern struct { + gr_interface: u32, + gr_group: struct_sockaddr_storage, +}; +pub const struct_group_source_req = extern struct { + gsr_interface: u32, + gsr_group: struct_sockaddr_storage, + gsr_source: struct_sockaddr_storage, +}; +pub const struct_ip_msfilter = extern struct { + imsf_multiaddr: struct_in_addr, + imsf_interface: struct_in_addr, + imsf_fmode: u32, + imsf_numsrc: u32, + imsf_slist: [1]struct_in_addr, +}; +pub const struct_group_filter = extern struct { + gf_interface: u32, + gf_group: struct_sockaddr_storage, + gf_fmode: u32, + gf_numsrc: u32, + gf_slist: [1]struct_sockaddr_storage, +}; +pub extern fn ntohl(__netlong: u32) u32; +pub extern fn ntohs(__netshort: u16) u16; +pub extern fn htonl(__hostlong: u32) u32; +pub extern fn htons(__hostshort: u16) u16; +pub extern fn bindresvport(__sockfd: c_int, __sock_in: [*c]struct_sockaddr_in) c_int; +pub extern fn bindresvport6(__sockfd: c_int, __sock_in: [*c]struct_sockaddr_in6) c_int; +pub const tcp_seq = u32; // /usr/include/netinet/tcp.h:109:10: warning: struct demoted to opaque type - has bitfield +const struct_unnamed_71 = opaque {}; // /usr/include/netinet/tcp.h:134:11: warning: struct demoted to opaque type - has bitfield +const struct_unnamed_72 = opaque {}; +const union_unnamed_70 = extern union { + unnamed_0: struct_unnamed_71, + unnamed_1: struct_unnamed_72, +}; +pub const struct_tcphdr = extern struct { + unnamed_0: union_unnamed_70, +}; +pub const TCP_ESTABLISHED: c_int = 1; +pub const TCP_SYN_SENT: c_int = 2; +pub const TCP_SYN_RECV: c_int = 3; +pub const TCP_FIN_WAIT1: c_int = 4; +pub const TCP_FIN_WAIT2: c_int = 5; +pub const TCP_TIME_WAIT: c_int = 6; +pub const TCP_CLOSE: c_int = 7; +pub const TCP_CLOSE_WAIT: c_int = 8; +pub const TCP_LAST_ACK: c_int = 9; +pub const TCP_LISTEN: c_int = 10; +pub const TCP_CLOSING: c_int = 11; +const enum_unnamed_73 = c_uint; +pub const TCP_CA_Open: c_int = 0; +pub const TCP_CA_Disorder: c_int = 1; +pub const TCP_CA_CWR: c_int = 2; +pub const TCP_CA_Recovery: c_int = 3; +pub const TCP_CA_Loss: c_int = 4; +pub const enum_tcp_ca_state = c_uint; // /usr/include/netinet/tcp.h:234:11: warning: struct demoted to opaque type - has bitfield +pub const struct_tcp_info = opaque {}; +pub const struct_tcp_md5sig = extern struct { + tcpm_addr: struct_sockaddr_storage, + tcpm_flags: u8, + tcpm_prefixlen: u8, + tcpm_keylen: u16, + __tcpm_pad: u32, + tcpm_key: [80]u8, +}; +pub const struct_tcp_repair_opt = extern struct { + opt_code: u32, + opt_val: u32, +}; +pub const TCP_NO_QUEUE: c_int = 0; +pub const TCP_RECV_QUEUE: c_int = 1; +pub const TCP_SEND_QUEUE: c_int = 2; +pub const TCP_QUEUES_NR: c_int = 3; +const enum_unnamed_74 = c_uint; +pub const struct_tcp_cookie_transactions = extern struct { + tcpct_flags: u16, + __tcpct_pad1: u8, + tcpct_cookie_desired: u8, + tcpct_s_data_desired: u16, + tcpct_used: u16, + tcpct_value: [536]u8, +}; +pub const struct_tcp_repair_window = extern struct { + snd_wl1: u32, + snd_wnd: u32, + max_window: u32, + rcv_wnd: u32, + rcv_wup: u32, +}; +pub const struct_tcp_zerocopy_receive = extern struct { + address: u64, + length: u32, + recv_skip_hint: u32, +}; +pub extern fn inet_addr(__cp: [*c]const u8) in_addr_t; +pub extern fn inet_lnaof(__in: struct_in_addr) in_addr_t; +pub extern fn inet_makeaddr(__net: in_addr_t, __host: in_addr_t) struct_in_addr; +pub extern fn inet_netof(__in: struct_in_addr) in_addr_t; +pub extern fn inet_network(__cp: [*c]const u8) in_addr_t; +pub extern fn inet_ntoa(__in: struct_in_addr) [*c]u8; +pub extern fn inet_pton(__af: c_int, noalias __cp: [*c]const u8, noalias __buf: ?*anyopaque) c_int; +pub extern fn inet_ntop(__af: c_int, noalias __cp: ?*const anyopaque, noalias __buf: [*c]u8, __len: socklen_t) [*c]const u8; +pub extern fn inet_aton(__cp: [*c]const u8, __inp: [*c]struct_in_addr) c_int; +pub extern fn inet_neta(__net: in_addr_t, __buf: [*c]u8, __len: usize) [*c]u8; +pub extern fn inet_net_ntop(__af: c_int, __cp: ?*const anyopaque, __bits: c_int, __buf: [*c]u8, __len: usize) [*c]u8; +pub extern fn inet_net_pton(__af: c_int, __cp: [*c]const u8, __buf: ?*anyopaque, __len: usize) c_int; +pub extern fn inet_nsap_addr(__cp: [*c]const u8, __buf: [*c]u8, __len: c_int) c_uint; +pub extern fn inet_nsap_ntoa(__len: c_int, __cp: [*c]const u8, __buf: [*c]u8) [*c]u8; +pub const struct_rpcent = extern struct { + r_name: [*c]u8, + r_aliases: [*c][*c]u8, + r_number: c_int, +}; +pub extern fn setrpcent(__stayopen: c_int) void; +pub extern fn endrpcent() void; +pub extern fn getrpcbyname(__name: [*c]const u8) [*c]struct_rpcent; +pub extern fn getrpcbynumber(__number: c_int) [*c]struct_rpcent; +pub extern fn getrpcent() [*c]struct_rpcent; +pub extern fn getrpcbyname_r(__name: [*c]const u8, __result_buf: [*c]struct_rpcent, __buffer: [*c]u8, __buflen: usize, __result: [*c][*c]struct_rpcent) c_int; +pub extern fn getrpcbynumber_r(__number: c_int, __result_buf: [*c]struct_rpcent, __buffer: [*c]u8, __buflen: usize, __result: [*c][*c]struct_rpcent) c_int; +pub extern fn getrpcent_r(__result_buf: [*c]struct_rpcent, __buffer: [*c]u8, __buflen: usize, __result: [*c][*c]struct_rpcent) c_int; +pub const struct_netent = extern struct { + n_name: [*c]u8, + n_aliases: [*c][*c]u8, + n_addrtype: c_int, + n_net: u32, +}; +pub extern fn __h_errno_location() [*c]c_int; +pub extern fn herror(__str: [*c]const u8) void; +pub extern fn hstrerror(__err_num: c_int) [*c]const u8; +pub const struct_hostent = extern struct { + h_name: [*c]u8, + h_aliases: [*c][*c]u8, + h_addrtype: c_int, + h_length: c_int, + h_addr_list: [*c][*c]u8, +}; +pub extern fn sethostent(__stay_open: c_int) void; +pub extern fn endhostent() void; +pub extern fn gethostent() [*c]struct_hostent; +pub extern fn gethostbyaddr(__addr: ?*const anyopaque, __len: __socklen_t, __type: c_int) [*c]struct_hostent; +pub extern fn gethostbyname(__name: [*c]const u8) [*c]struct_hostent; +pub extern fn gethostbyname2(__name: [*c]const u8, __af: c_int) [*c]struct_hostent; +pub extern fn gethostent_r(noalias __result_buf: [*c]struct_hostent, noalias __buf: [*c]u8, __buflen: usize, noalias __result: [*c][*c]struct_hostent, noalias __h_errnop: [*c]c_int) c_int; +pub extern fn gethostbyaddr_r(noalias __addr: ?*const anyopaque, __len: __socklen_t, __type: c_int, noalias __result_buf: [*c]struct_hostent, noalias __buf: [*c]u8, __buflen: usize, noalias __result: [*c][*c]struct_hostent, noalias __h_errnop: [*c]c_int) c_int; +pub extern fn gethostbyname_r(noalias __name: [*c]const u8, noalias __result_buf: [*c]struct_hostent, noalias __buf: [*c]u8, __buflen: usize, noalias __result: [*c][*c]struct_hostent, noalias __h_errnop: [*c]c_int) c_int; +pub extern fn gethostbyname2_r(noalias __name: [*c]const u8, __af: c_int, noalias __result_buf: [*c]struct_hostent, noalias __buf: [*c]u8, __buflen: usize, noalias __result: [*c][*c]struct_hostent, noalias __h_errnop: [*c]c_int) c_int; +pub extern fn setnetent(__stay_open: c_int) void; +pub extern fn endnetent() void; +pub extern fn getnetent() [*c]struct_netent; +pub extern fn getnetbyaddr(__net: u32, __type: c_int) [*c]struct_netent; +pub extern fn getnetbyname(__name: [*c]const u8) [*c]struct_netent; +pub extern fn getnetent_r(noalias __result_buf: [*c]struct_netent, noalias __buf: [*c]u8, __buflen: usize, noalias __result: [*c][*c]struct_netent, noalias __h_errnop: [*c]c_int) c_int; +pub extern fn getnetbyaddr_r(__net: u32, __type: c_int, noalias __result_buf: [*c]struct_netent, noalias __buf: [*c]u8, __buflen: usize, noalias __result: [*c][*c]struct_netent, noalias __h_errnop: [*c]c_int) c_int; +pub extern fn getnetbyname_r(noalias __name: [*c]const u8, noalias __result_buf: [*c]struct_netent, noalias __buf: [*c]u8, __buflen: usize, noalias __result: [*c][*c]struct_netent, noalias __h_errnop: [*c]c_int) c_int; +pub const struct_servent = extern struct { + s_name: [*c]u8, + s_aliases: [*c][*c]u8, + s_port: c_int, + s_proto: [*c]u8, +}; +pub extern fn setservent(__stay_open: c_int) void; +pub extern fn endservent() void; +pub extern fn getservent() [*c]struct_servent; +pub extern fn getservbyname(__name: [*c]const u8, __proto: [*c]const u8) [*c]struct_servent; +pub extern fn getservbyport(__port: c_int, __proto: [*c]const u8) [*c]struct_servent; +pub extern fn getservent_r(noalias __result_buf: [*c]struct_servent, noalias __buf: [*c]u8, __buflen: usize, noalias __result: [*c][*c]struct_servent) c_int; +pub extern fn getservbyname_r(noalias __name: [*c]const u8, noalias __proto: [*c]const u8, noalias __result_buf: [*c]struct_servent, noalias __buf: [*c]u8, __buflen: usize, noalias __result: [*c][*c]struct_servent) c_int; +pub extern fn getservbyport_r(__port: c_int, noalias __proto: [*c]const u8, noalias __result_buf: [*c]struct_servent, noalias __buf: [*c]u8, __buflen: usize, noalias __result: [*c][*c]struct_servent) c_int; +pub const struct_protoent = extern struct { + p_name: [*c]u8, + p_aliases: [*c][*c]u8, + p_proto: c_int, +}; +pub extern fn setprotoent(__stay_open: c_int) void; +pub extern fn endprotoent() void; +pub extern fn getprotoent() [*c]struct_protoent; +pub extern fn getprotobyname(__name: [*c]const u8) [*c]struct_protoent; +pub extern fn getprotobynumber(__proto: c_int) [*c]struct_protoent; +pub extern fn getprotoent_r(noalias __result_buf: [*c]struct_protoent, noalias __buf: [*c]u8, __buflen: usize, noalias __result: [*c][*c]struct_protoent) c_int; +pub extern fn getprotobyname_r(noalias __name: [*c]const u8, noalias __result_buf: [*c]struct_protoent, noalias __buf: [*c]u8, __buflen: usize, noalias __result: [*c][*c]struct_protoent) c_int; +pub extern fn getprotobynumber_r(__proto: c_int, noalias __result_buf: [*c]struct_protoent, noalias __buf: [*c]u8, __buflen: usize, noalias __result: [*c][*c]struct_protoent) c_int; +pub extern fn setnetgrent(__netgroup: [*c]const u8) c_int; +pub extern fn endnetgrent() void; +pub extern fn getnetgrent(noalias __hostp: [*c][*c]u8, noalias __userp: [*c][*c]u8, noalias __domainp: [*c][*c]u8) c_int; +pub extern fn innetgr(__netgroup: [*c]const u8, __host: [*c]const u8, __user: [*c]const u8, __domain: [*c]const u8) c_int; +pub extern fn getnetgrent_r(noalias __hostp: [*c][*c]u8, noalias __userp: [*c][*c]u8, noalias __domainp: [*c][*c]u8, noalias __buffer: [*c]u8, __buflen: usize) c_int; +pub extern fn rcmd(noalias __ahost: [*c][*c]u8, __rport: c_ushort, noalias __locuser: [*c]const u8, noalias __remuser: [*c]const u8, noalias __cmd: [*c]const u8, noalias __fd2p: [*c]c_int) c_int; +pub extern fn rcmd_af(noalias __ahost: [*c][*c]u8, __rport: c_ushort, noalias __locuser: [*c]const u8, noalias __remuser: [*c]const u8, noalias __cmd: [*c]const u8, noalias __fd2p: [*c]c_int, __af: sa_family_t) c_int; +pub extern fn rexec(noalias __ahost: [*c][*c]u8, __rport: c_int, noalias __name: [*c]const u8, noalias __pass: [*c]const u8, noalias __cmd: [*c]const u8, noalias __fd2p: [*c]c_int) c_int; +pub extern fn rexec_af(noalias __ahost: [*c][*c]u8, __rport: c_int, noalias __name: [*c]const u8, noalias __pass: [*c]const u8, noalias __cmd: [*c]const u8, noalias __fd2p: [*c]c_int, __af: sa_family_t) c_int; +pub extern fn ruserok(__rhost: [*c]const u8, __suser: c_int, __remuser: [*c]const u8, __locuser: [*c]const u8) c_int; +pub extern fn ruserok_af(__rhost: [*c]const u8, __suser: c_int, __remuser: [*c]const u8, __locuser: [*c]const u8, __af: sa_family_t) c_int; +pub extern fn iruserok(__raddr: u32, __suser: c_int, __remuser: [*c]const u8, __locuser: [*c]const u8) c_int; +pub extern fn iruserok_af(__raddr: ?*const anyopaque, __suser: c_int, __remuser: [*c]const u8, __locuser: [*c]const u8, __af: sa_family_t) c_int; +pub extern fn rresvport(__alport: [*c]c_int) c_int; +pub extern fn rresvport_af(__alport: [*c]c_int, __af: sa_family_t) c_int; +pub const struct_addrinfo = extern struct { + ai_flags: c_int, + ai_family: c_int, + ai_socktype: c_int, + ai_protocol: c_int, + ai_addrlen: socklen_t, + ai_addr: [*c]struct_sockaddr, + ai_canonname: [*c]u8, + ai_next: [*c]struct_addrinfo, +}; +pub extern fn getaddrinfo(noalias __name: [*c]const u8, noalias __service: [*c]const u8, noalias __req: [*c]const struct_addrinfo, noalias __pai: [*c][*c]struct_addrinfo) c_int; +pub extern fn freeaddrinfo(__ai: [*c]struct_addrinfo) void; +pub extern fn gai_strerror(__ecode: c_int) [*c]const u8; +pub extern fn getnameinfo(noalias __sa: [*c]const struct_sockaddr, __salen: socklen_t, noalias __host: [*c]u8, __hostlen: socklen_t, noalias __serv: [*c]u8, __servlen: socklen_t, __flags: c_int) c_int; +pub const struct_passwd = extern struct { + pw_name: [*c]u8, + pw_passwd: [*c]u8, + pw_uid: __uid_t, + pw_gid: __gid_t, + pw_gecos: [*c]u8, + pw_dir: [*c]u8, + pw_shell: [*c]u8, +}; +pub extern fn setpwent() void; +pub extern fn endpwent() void; +pub extern fn getpwent() [*c]struct_passwd; +pub extern fn fgetpwent(__stream: [*c]FILE) [*c]struct_passwd; +pub extern fn putpwent(noalias __p: [*c]const struct_passwd, noalias __f: [*c]FILE) c_int; +pub extern fn getpwuid(__uid: __uid_t) [*c]struct_passwd; +pub extern fn getpwnam(__name: [*c]const u8) [*c]struct_passwd; +pub extern fn getpwent_r(noalias __resultbuf: [*c]struct_passwd, noalias __buffer: [*c]u8, __buflen: usize, noalias __result: [*c][*c]struct_passwd) c_int; +pub extern fn getpwuid_r(__uid: __uid_t, noalias __resultbuf: [*c]struct_passwd, noalias __buffer: [*c]u8, __buflen: usize, noalias __result: [*c][*c]struct_passwd) c_int; +pub extern fn getpwnam_r(noalias __name: [*c]const u8, noalias __resultbuf: [*c]struct_passwd, noalias __buffer: [*c]u8, __buflen: usize, noalias __result: [*c][*c]struct_passwd) c_int; +pub extern fn fgetpwent_r(noalias __stream: [*c]FILE, noalias __resultbuf: [*c]struct_passwd, noalias __buffer: [*c]u8, __buflen: usize, noalias __result: [*c][*c]struct_passwd) c_int; +pub const sem_t = extern union { + __size: [32]u8, + __align: c_long, +}; +pub extern fn sem_init(__sem: [*c]sem_t, __pshared: c_int, __value: c_uint) c_int; +pub extern fn sem_destroy(__sem: [*c]sem_t) c_int; +pub extern fn sem_open(__name: [*c]const u8, __oflag: c_int, ...) [*c]sem_t; +pub extern fn sem_close(__sem: [*c]sem_t) c_int; +pub extern fn sem_unlink(__name: [*c]const u8) c_int; +pub extern fn sem_wait(__sem: [*c]sem_t) c_int; +pub extern fn sem_timedwait(noalias __sem: [*c]sem_t, noalias __abstime: [*c]const struct_timespec) c_int; +pub extern fn sem_trywait(__sem: [*c]sem_t) c_int; +pub extern fn sem_post(__sem: [*c]sem_t) c_int; +pub extern fn sem_getvalue(noalias __sem: [*c]sem_t, noalias __sval: [*c]c_int) c_int; +pub const struct_sched_param = extern struct { + sched_priority: c_int, +}; +pub const __cpu_mask = c_ulong; +pub const cpu_set_t = extern struct { + __bits: [16]__cpu_mask, +}; +pub extern fn __sched_cpucount(__setsize: usize, __setp: [*c]const cpu_set_t) c_int; +pub extern fn __sched_cpualloc(__count: usize) [*c]cpu_set_t; +pub extern fn __sched_cpufree(__set: [*c]cpu_set_t) void; +pub extern fn sched_setparam(__pid: __pid_t, __param: [*c]const struct_sched_param) c_int; +pub extern fn sched_getparam(__pid: __pid_t, __param: [*c]struct_sched_param) c_int; +pub extern fn sched_setscheduler(__pid: __pid_t, __policy: c_int, __param: [*c]const struct_sched_param) c_int; +pub extern fn sched_getscheduler(__pid: __pid_t) c_int; +pub extern fn sched_yield() c_int; +pub extern fn sched_get_priority_max(__algorithm: c_int) c_int; +pub extern fn sched_get_priority_min(__algorithm: c_int) c_int; +pub extern fn sched_rr_get_interval(__pid: __pid_t, __t: [*c]struct_timespec) c_int; +pub const __jmp_buf = [8]c_long; +pub const struct___jmp_buf_tag = extern struct { + __jmpbuf: __jmp_buf, + __mask_was_saved: c_int, + __saved_mask: __sigset_t, +}; +pub const PTHREAD_CREATE_JOINABLE: c_int = 0; +pub const PTHREAD_CREATE_DETACHED: c_int = 1; +const enum_unnamed_75 = c_uint; +pub const PTHREAD_MUTEX_TIMED_NP: c_int = 0; +pub const PTHREAD_MUTEX_RECURSIVE_NP: c_int = 1; +pub const PTHREAD_MUTEX_ERRORCHECK_NP: c_int = 2; +pub const PTHREAD_MUTEX_ADAPTIVE_NP: c_int = 3; +pub const PTHREAD_MUTEX_NORMAL: c_int = 0; +pub const PTHREAD_MUTEX_RECURSIVE: c_int = 1; +pub const PTHREAD_MUTEX_ERRORCHECK: c_int = 2; +pub const PTHREAD_MUTEX_DEFAULT: c_int = 0; +const enum_unnamed_76 = c_uint; +pub const PTHREAD_MUTEX_STALLED: c_int = 0; +pub const PTHREAD_MUTEX_STALLED_NP: c_int = 0; +pub const PTHREAD_MUTEX_ROBUST: c_int = 1; +pub const PTHREAD_MUTEX_ROBUST_NP: c_int = 1; +const enum_unnamed_77 = c_uint; +pub const PTHREAD_PRIO_NONE: c_int = 0; +pub const PTHREAD_PRIO_INHERIT: c_int = 1; +pub const PTHREAD_PRIO_PROTECT: c_int = 2; +const enum_unnamed_78 = c_uint; +pub const PTHREAD_RWLOCK_PREFER_READER_NP: c_int = 0; +pub const PTHREAD_RWLOCK_PREFER_WRITER_NP: c_int = 1; +pub const PTHREAD_RWLOCK_PREFER_WRITER_NONRECURSIVE_NP: c_int = 2; +pub const PTHREAD_RWLOCK_DEFAULT_NP: c_int = 0; +const enum_unnamed_79 = c_uint; +pub const PTHREAD_INHERIT_SCHED: c_int = 0; +pub const PTHREAD_EXPLICIT_SCHED: c_int = 1; +const enum_unnamed_80 = c_uint; +pub const PTHREAD_SCOPE_SYSTEM: c_int = 0; +pub const PTHREAD_SCOPE_PROCESS: c_int = 1; +const enum_unnamed_81 = c_uint; +pub const PTHREAD_PROCESS_PRIVATE: c_int = 0; +pub const PTHREAD_PROCESS_SHARED: c_int = 1; +const enum_unnamed_82 = c_uint; +pub const struct__pthread_cleanup_buffer = extern struct { + __routine: ?*const fn (?*anyopaque) callconv(.C) void, + __arg: ?*anyopaque, + __canceltype: c_int, + __prev: [*c]struct__pthread_cleanup_buffer, +}; +pub const PTHREAD_CANCEL_ENABLE: c_int = 0; +pub const PTHREAD_CANCEL_DISABLE: c_int = 1; +const enum_unnamed_83 = c_uint; +pub const PTHREAD_CANCEL_DEFERRED: c_int = 0; +pub const PTHREAD_CANCEL_ASYNCHRONOUS: c_int = 1; +const enum_unnamed_84 = c_uint; +pub extern fn pthread_create(noalias __newthread: [*c]pthread_t, noalias __attr: [*c]const pthread_attr_t, __start_routine: ?*const fn (?*anyopaque) callconv(.C) ?*anyopaque, noalias __arg: ?*anyopaque) c_int; +pub extern fn pthread_exit(__retval: ?*anyopaque) noreturn; +pub extern fn pthread_join(__th: pthread_t, __thread_return: [*c]?*anyopaque) c_int; +pub extern fn pthread_detach(__th: pthread_t) c_int; +pub extern fn pthread_self() pthread_t; +pub extern fn pthread_equal(__thread1: pthread_t, __thread2: pthread_t) c_int; +pub extern fn pthread_attr_init(__attr: [*c]pthread_attr_t) c_int; +pub extern fn pthread_attr_destroy(__attr: [*c]pthread_attr_t) c_int; +pub extern fn pthread_attr_getdetachstate(__attr: [*c]const pthread_attr_t, __detachstate: [*c]c_int) c_int; +pub extern fn pthread_attr_setdetachstate(__attr: [*c]pthread_attr_t, __detachstate: c_int) c_int; +pub extern fn pthread_attr_getguardsize(__attr: [*c]const pthread_attr_t, __guardsize: [*c]usize) c_int; +pub extern fn pthread_attr_setguardsize(__attr: [*c]pthread_attr_t, __guardsize: usize) c_int; +pub extern fn pthread_attr_getschedparam(noalias __attr: [*c]const pthread_attr_t, noalias __param: [*c]struct_sched_param) c_int; +pub extern fn pthread_attr_setschedparam(noalias __attr: [*c]pthread_attr_t, noalias __param: [*c]const struct_sched_param) c_int; +pub extern fn pthread_attr_getschedpolicy(noalias __attr: [*c]const pthread_attr_t, noalias __policy: [*c]c_int) c_int; +pub extern fn pthread_attr_setschedpolicy(__attr: [*c]pthread_attr_t, __policy: c_int) c_int; +pub extern fn pthread_attr_getinheritsched(noalias __attr: [*c]const pthread_attr_t, noalias __inherit: [*c]c_int) c_int; +pub extern fn pthread_attr_setinheritsched(__attr: [*c]pthread_attr_t, __inherit: c_int) c_int; +pub extern fn pthread_attr_getscope(noalias __attr: [*c]const pthread_attr_t, noalias __scope: [*c]c_int) c_int; +pub extern fn pthread_attr_setscope(__attr: [*c]pthread_attr_t, __scope: c_int) c_int; +pub extern fn pthread_attr_getstackaddr(noalias __attr: [*c]const pthread_attr_t, noalias __stackaddr: [*c]?*anyopaque) c_int; +pub extern fn pthread_attr_setstackaddr(__attr: [*c]pthread_attr_t, __stackaddr: ?*anyopaque) c_int; +pub extern fn pthread_attr_getstacksize(noalias __attr: [*c]const pthread_attr_t, noalias __stacksize: [*c]usize) c_int; +pub extern fn pthread_attr_setstacksize(__attr: [*c]pthread_attr_t, __stacksize: usize) c_int; +pub extern fn pthread_attr_getstack(noalias __attr: [*c]const pthread_attr_t, noalias __stackaddr: [*c]?*anyopaque, noalias __stacksize: [*c]usize) c_int; +pub extern fn pthread_attr_setstack(__attr: [*c]pthread_attr_t, __stackaddr: ?*anyopaque, __stacksize: usize) c_int; +pub extern fn pthread_setschedparam(__target_thread: pthread_t, __policy: c_int, __param: [*c]const struct_sched_param) c_int; +pub extern fn pthread_getschedparam(__target_thread: pthread_t, noalias __policy: [*c]c_int, noalias __param: [*c]struct_sched_param) c_int; +pub extern fn pthread_setschedprio(__target_thread: pthread_t, __prio: c_int) c_int; +pub extern fn pthread_once(__once_control: [*c]pthread_once_t, __init_routine: ?*const fn () callconv(.C) void) c_int; +pub extern fn pthread_setcancelstate(__state: c_int, __oldstate: [*c]c_int) c_int; +pub extern fn pthread_setcanceltype(__type: c_int, __oldtype: [*c]c_int) c_int; +pub extern fn pthread_cancel(__th: pthread_t) c_int; +pub extern fn pthread_testcancel() void; +pub const struct___cancel_jmp_buf_tag = extern struct { + __cancel_jmp_buf: __jmp_buf, + __mask_was_saved: c_int, +}; +pub const __pthread_unwind_buf_t = extern struct { + __cancel_jmp_buf: [1]struct___cancel_jmp_buf_tag, + __pad: [4]?*anyopaque, +}; +pub const struct___pthread_cleanup_frame = extern struct { + __cancel_routine: ?*const fn (?*anyopaque) callconv(.C) void, + __cancel_arg: ?*anyopaque, + __do_it: c_int, + __cancel_type: c_int, +}; +pub extern fn __pthread_register_cancel(__buf: [*c]__pthread_unwind_buf_t) void; +pub extern fn __pthread_unregister_cancel(__buf: [*c]__pthread_unwind_buf_t) void; +pub extern fn __pthread_unwind_next(__buf: [*c]__pthread_unwind_buf_t) noreturn; +pub extern fn __sigsetjmp(__env: [*c]struct___jmp_buf_tag, __savemask: c_int) c_int; +pub extern fn pthread_mutex_init(__mutex: [*c]pthread_mutex_t, __mutexattr: [*c]const pthread_mutexattr_t) c_int; +pub extern fn pthread_mutex_destroy(__mutex: [*c]pthread_mutex_t) c_int; +pub extern fn pthread_mutex_trylock(__mutex: [*c]pthread_mutex_t) c_int; +pub extern fn pthread_mutex_lock(__mutex: [*c]pthread_mutex_t) c_int; +pub extern fn pthread_mutex_timedlock(noalias __mutex: [*c]pthread_mutex_t, noalias __abstime: [*c]const struct_timespec) c_int; +pub extern fn pthread_mutex_unlock(__mutex: [*c]pthread_mutex_t) c_int; +pub extern fn pthread_mutex_getprioceiling(noalias __mutex: [*c]const pthread_mutex_t, noalias __prioceiling: [*c]c_int) c_int; +pub extern fn pthread_mutex_setprioceiling(noalias __mutex: [*c]pthread_mutex_t, __prioceiling: c_int, noalias __old_ceiling: [*c]c_int) c_int; +pub extern fn pthread_mutex_consistent(__mutex: [*c]pthread_mutex_t) c_int; +pub extern fn pthread_mutexattr_init(__attr: [*c]pthread_mutexattr_t) c_int; +pub extern fn pthread_mutexattr_destroy(__attr: [*c]pthread_mutexattr_t) c_int; +pub extern fn pthread_mutexattr_getpshared(noalias __attr: [*c]const pthread_mutexattr_t, noalias __pshared: [*c]c_int) c_int; +pub extern fn pthread_mutexattr_setpshared(__attr: [*c]pthread_mutexattr_t, __pshared: c_int) c_int; +pub extern fn pthread_mutexattr_gettype(noalias __attr: [*c]const pthread_mutexattr_t, noalias __kind: [*c]c_int) c_int; +pub extern fn pthread_mutexattr_settype(__attr: [*c]pthread_mutexattr_t, __kind: c_int) c_int; +pub extern fn pthread_mutexattr_getprotocol(noalias __attr: [*c]const pthread_mutexattr_t, noalias __protocol: [*c]c_int) c_int; +pub extern fn pthread_mutexattr_setprotocol(__attr: [*c]pthread_mutexattr_t, __protocol: c_int) c_int; +pub extern fn pthread_mutexattr_getprioceiling(noalias __attr: [*c]const pthread_mutexattr_t, noalias __prioceiling: [*c]c_int) c_int; +pub extern fn pthread_mutexattr_setprioceiling(__attr: [*c]pthread_mutexattr_t, __prioceiling: c_int) c_int; +pub extern fn pthread_mutexattr_getrobust(__attr: [*c]const pthread_mutexattr_t, __robustness: [*c]c_int) c_int; +pub extern fn pthread_mutexattr_setrobust(__attr: [*c]pthread_mutexattr_t, __robustness: c_int) c_int; +pub extern fn pthread_rwlock_init(noalias __rwlock: [*c]pthread_rwlock_t, noalias __attr: [*c]const pthread_rwlockattr_t) c_int; +pub extern fn pthread_rwlock_destroy(__rwlock: [*c]pthread_rwlock_t) c_int; +pub extern fn pthread_rwlock_rdlock(__rwlock: [*c]pthread_rwlock_t) c_int; +pub extern fn pthread_rwlock_tryrdlock(__rwlock: [*c]pthread_rwlock_t) c_int; +pub extern fn pthread_rwlock_timedrdlock(noalias __rwlock: [*c]pthread_rwlock_t, noalias __abstime: [*c]const struct_timespec) c_int; +pub extern fn pthread_rwlock_wrlock(__rwlock: [*c]pthread_rwlock_t) c_int; +pub extern fn pthread_rwlock_trywrlock(__rwlock: [*c]pthread_rwlock_t) c_int; +pub extern fn pthread_rwlock_timedwrlock(noalias __rwlock: [*c]pthread_rwlock_t, noalias __abstime: [*c]const struct_timespec) c_int; +pub extern fn pthread_rwlock_unlock(__rwlock: [*c]pthread_rwlock_t) c_int; +pub extern fn pthread_rwlockattr_init(__attr: [*c]pthread_rwlockattr_t) c_int; +pub extern fn pthread_rwlockattr_destroy(__attr: [*c]pthread_rwlockattr_t) c_int; +pub extern fn pthread_rwlockattr_getpshared(noalias __attr: [*c]const pthread_rwlockattr_t, noalias __pshared: [*c]c_int) c_int; +pub extern fn pthread_rwlockattr_setpshared(__attr: [*c]pthread_rwlockattr_t, __pshared: c_int) c_int; +pub extern fn pthread_rwlockattr_getkind_np(noalias __attr: [*c]const pthread_rwlockattr_t, noalias __pref: [*c]c_int) c_int; +pub extern fn pthread_rwlockattr_setkind_np(__attr: [*c]pthread_rwlockattr_t, __pref: c_int) c_int; +pub extern fn pthread_cond_init(noalias __cond: [*c]pthread_cond_t, noalias __cond_attr: [*c]const pthread_condattr_t) c_int; +pub extern fn pthread_cond_destroy(__cond: [*c]pthread_cond_t) c_int; +pub extern fn pthread_cond_signal(__cond: [*c]pthread_cond_t) c_int; +pub extern fn pthread_cond_broadcast(__cond: [*c]pthread_cond_t) c_int; +pub extern fn pthread_cond_wait(noalias __cond: [*c]pthread_cond_t, noalias __mutex: [*c]pthread_mutex_t) c_int; +pub extern fn pthread_cond_timedwait(noalias __cond: [*c]pthread_cond_t, noalias __mutex: [*c]pthread_mutex_t, noalias __abstime: [*c]const struct_timespec) c_int; +pub extern fn pthread_condattr_init(__attr: [*c]pthread_condattr_t) c_int; +pub extern fn pthread_condattr_destroy(__attr: [*c]pthread_condattr_t) c_int; +pub extern fn pthread_condattr_getpshared(noalias __attr: [*c]const pthread_condattr_t, noalias __pshared: [*c]c_int) c_int; +pub extern fn pthread_condattr_setpshared(__attr: [*c]pthread_condattr_t, __pshared: c_int) c_int; +pub extern fn pthread_condattr_getclock(noalias __attr: [*c]const pthread_condattr_t, noalias __clock_id: [*c]__clockid_t) c_int; +pub extern fn pthread_condattr_setclock(__attr: [*c]pthread_condattr_t, __clock_id: __clockid_t) c_int; +pub extern fn pthread_spin_init(__lock: [*c]volatile pthread_spinlock_t, __pshared: c_int) c_int; +pub extern fn pthread_spin_destroy(__lock: [*c]volatile pthread_spinlock_t) c_int; +pub extern fn pthread_spin_lock(__lock: [*c]volatile pthread_spinlock_t) c_int; +pub extern fn pthread_spin_trylock(__lock: [*c]volatile pthread_spinlock_t) c_int; +pub extern fn pthread_spin_unlock(__lock: [*c]volatile pthread_spinlock_t) c_int; +pub extern fn pthread_barrier_init(noalias __barrier: [*c]pthread_barrier_t, noalias __attr: [*c]const pthread_barrierattr_t, __count: c_uint) c_int; +pub extern fn pthread_barrier_destroy(__barrier: [*c]pthread_barrier_t) c_int; +pub extern fn pthread_barrier_wait(__barrier: [*c]pthread_barrier_t) c_int; +pub extern fn pthread_barrierattr_init(__attr: [*c]pthread_barrierattr_t) c_int; +pub extern fn pthread_barrierattr_destroy(__attr: [*c]pthread_barrierattr_t) c_int; +pub extern fn pthread_barrierattr_getpshared(noalias __attr: [*c]const pthread_barrierattr_t, noalias __pshared: [*c]c_int) c_int; +pub extern fn pthread_barrierattr_setpshared(__attr: [*c]pthread_barrierattr_t, __pshared: c_int) c_int; +pub extern fn pthread_key_create(__key: [*c]pthread_key_t, __destr_function: ?*const fn (?*anyopaque) callconv(.C) void) c_int; +pub extern fn pthread_key_delete(__key: pthread_key_t) c_int; +pub extern fn pthread_getspecific(__key: pthread_key_t) ?*anyopaque; +pub extern fn pthread_setspecific(__key: pthread_key_t, __pointer: ?*const anyopaque) c_int; +pub extern fn pthread_getcpuclockid(__thread_id: pthread_t, __clock_id: [*c]__clockid_t) c_int; +pub extern fn pthread_atfork(__prepare: ?*const fn () callconv(.C) void, __parent: ?*const fn () callconv(.C) void, __child: ?*const fn () callconv(.C) void) c_int; +const union_unnamed_85 = extern union { + unused: ?*anyopaque, + count: c_uint, +}; +pub const uv__io_cb = ?*const fn ([*c]struct_uv_loop_s, [*c]struct_uv__io_s, c_uint) callconv(.C) void; +pub const struct_uv__io_s = extern struct { + cb: uv__io_cb, + pending_queue: [2]?*anyopaque, + watcher_queue: [2]?*anyopaque, + pevents: c_uint, + events: c_uint, + fd: c_int, +}; +pub const uv__io_t = struct_uv__io_s; +pub const uv_mutex_t = pthread_mutex_t; +pub const uv_loop_t = struct_uv_loop_s; +const union_unnamed_86 = extern union { + fd: c_int, + reserved: [4]?*anyopaque, +}; +pub const struct_uv_handle_s = extern struct { + data: ?*anyopaque, + loop: [*c]uv_loop_t, + type: uv_handle_type, + close_cb: uv_close_cb, + handle_queue: [2]?*anyopaque, + u: union_unnamed_86, + next_closing: [*c]uv_handle_t, + flags: c_uint, +}; +pub const uv_handle_t = struct_uv_handle_s; +pub const uv_close_cb = ?*const fn ([*c]uv_handle_t) callconv(.C) void; +const union_unnamed_87 = extern union { + fd: c_int, + reserved: [4]?*anyopaque, +}; +pub const uv_async_cb = ?*const fn ([*c]uv_async_t) callconv(.C) void; +pub const struct_uv_async_s = extern struct { + data: ?*anyopaque, + loop: [*c]uv_loop_t, + type: uv_handle_type, + close_cb: uv_close_cb, + handle_queue: [2]?*anyopaque, + u: union_unnamed_87, + next_closing: [*c]uv_handle_t, + flags: c_uint, + async_cb: uv_async_cb, + queue: [2]?*anyopaque, + pending: c_int, +}; +pub const uv_async_t = struct_uv_async_s; +pub const uv_rwlock_t = pthread_rwlock_t; +const struct_unnamed_88 = extern struct { + min: ?*anyopaque, + nelts: c_uint, +}; +const union_unnamed_89 = extern union { + fd: c_int, + reserved: [4]?*anyopaque, +}; +pub const uv_signal_cb = ?*const fn ([*c]uv_signal_t, c_int) callconv(.C) void; +const struct_unnamed_90 = extern struct { + rbe_left: [*c]struct_uv_signal_s, + rbe_right: [*c]struct_uv_signal_s, + rbe_parent: [*c]struct_uv_signal_s, + rbe_color: c_int, +}; +pub const struct_uv_signal_s = extern struct { + data: ?*anyopaque, + loop: [*c]uv_loop_t, + type: uv_handle_type, + close_cb: uv_close_cb, + handle_queue: [2]?*anyopaque, + u: union_unnamed_89, + next_closing: [*c]uv_handle_t, + flags: c_uint, + signal_cb: uv_signal_cb, + signum: c_int, + tree_entry: struct_unnamed_90, + caught_signals: c_uint, + dispatched_signals: c_uint, +}; +pub const uv_signal_t = struct_uv_signal_s; +pub const struct_uv_loop_s = extern struct { + data: ?*anyopaque, + active_handles: c_uint, + handle_queue: [2]?*anyopaque, + active_reqs: union_unnamed_85, + internal_fields: ?*anyopaque, + stop_flag: c_uint, + flags: c_ulong, + backend_fd: c_int, + pending_queue: [2]?*anyopaque, + watcher_queue: [2]?*anyopaque, + watchers: [*c][*c]uv__io_t, + nwatchers: c_uint, + nfds: c_uint, + wq: [2]?*anyopaque, + wq_mutex: uv_mutex_t, + wq_async: uv_async_t, + cloexec_lock: uv_rwlock_t, + closing_handles: [*c]uv_handle_t, + process_handles: [2]?*anyopaque, + prepare_handles: [2]?*anyopaque, + check_handles: [2]?*anyopaque, + idle_handles: [2]?*anyopaque, + async_handles: [2]?*anyopaque, + async_unused: ?*const fn () callconv(.C) void, + async_io_watcher: uv__io_t, + async_wfd: c_int, + timer_heap: struct_unnamed_88, + timer_counter: u64, + time: u64, + signal_pipefd: [2]c_int, + signal_io_watcher: uv__io_t, + child_watcher: uv_signal_t, + emfile_fd: c_int, + inotify_read_watcher: uv__io_t, + inotify_watchers: ?*anyopaque, + inotify_fd: c_int, +}; +pub const struct_uv__work = extern struct { + work: ?*const fn ([*c]struct_uv__work) callconv(.C) void, + done: ?*const fn ([*c]struct_uv__work, c_int) callconv(.C) void, + loop: [*c]struct_uv_loop_s, + wq: [2]?*anyopaque, +}; +pub const struct_uv_buf_t = extern struct { + base: [*c]u8, + len: usize, +}; +pub const uv_buf_t = struct_uv_buf_t; +pub const uv_file = c_int; +pub const uv_os_sock_t = c_int; +pub const uv_os_fd_t = c_int; +pub const uv_pid_t = pid_t; +pub const uv_once_t = pthread_once_t; +pub const uv_thread_t = pthread_t; +pub const uv_sem_t = sem_t; +pub const uv_cond_t = pthread_cond_t; +pub const uv_key_t = pthread_key_t; +pub const uv_barrier_t = pthread_barrier_t; +pub const uv_gid_t = gid_t; +pub const uv_uid_t = uid_t; +pub const uv__dirent_t = struct_dirent; +pub const uv_lib_t = extern struct { + handle: ?*anyopaque, + errmsg: [*c]u8, +}; +pub const UV_E2BIG: c_int = -7; +pub const UV_EACCES: c_int = -13; +pub const UV_EADDRINUSE: c_int = -98; +pub const UV_EADDRNOTAVAIL: c_int = -99; +pub const UV_EAFNOSUPPORT: c_int = -97; +pub const UV_EAGAIN: c_int = -11; +pub const UV_EAI_ADDRFAMILY: c_int = -3000; +pub const UV_EAI_AGAIN: c_int = -3001; +pub const UV_EAI_BADFLAGS: c_int = -3002; +pub const UV_EAI_BADHINTS: c_int = -3013; +pub const UV_EAI_CANCELED: c_int = -3003; +pub const UV_EAI_FAIL: c_int = -3004; +pub const UV_EAI_FAMILY: c_int = -3005; +pub const UV_EAI_MEMORY: c_int = -3006; +pub const UV_EAI_NODATA: c_int = -3007; +pub const UV_EAI_NONAME: c_int = -3008; +pub const UV_EAI_OVERFLOW: c_int = -3009; +pub const UV_EAI_PROTOCOL: c_int = -3014; +pub const UV_EAI_SERVICE: c_int = -3010; +pub const UV_EAI_SOCKTYPE: c_int = -3011; +pub const UV_EALREADY: c_int = -114; +pub const UV_EBADF: c_int = -9; +pub const UV_EBUSY: c_int = -16; +pub const UV_ECANCELED: c_int = -125; +pub const UV_ECHARSET: c_int = -4080; +pub const UV_ECONNABORTED: c_int = -103; +pub const UV_ECONNREFUSED: c_int = -111; +pub const UV_ECONNRESET: c_int = -104; +pub const UV_EDESTADDRREQ: c_int = -89; +pub const UV_EEXIST: c_int = -17; +pub const UV_EFAULT: c_int = -14; +pub const UV_EFBIG: c_int = -27; +pub const UV_EHOSTUNREACH: c_int = -113; +pub const UV_EINTR: c_int = -4; +pub const UV_EINVAL: c_int = -22; +pub const UV_EIO: c_int = -5; +pub const UV_EISCONN: c_int = -106; +pub const UV_EISDIR: c_int = -21; +pub const UV_ELOOP: c_int = -40; +pub const UV_EMFILE: c_int = -24; +pub const UV_EMSGSIZE: c_int = -90; +pub const UV_ENAMETOOLONG: c_int = -36; +pub const UV_ENETDOWN: c_int = -100; +pub const UV_ENETUNREACH: c_int = -101; +pub const UV_ENFILE: c_int = -23; +pub const UV_ENOBUFS: c_int = -105; +pub const UV_ENODEV: c_int = -19; +pub const UV_ENOENT: c_int = -2; +pub const UV_ENOMEM: c_int = -12; +pub const UV_ENONET: c_int = -64; +pub const UV_ENOPROTOOPT: c_int = -92; +pub const UV_ENOSPC: c_int = -28; +pub const UV_ENOSYS: c_int = -38; +pub const UV_ENOTCONN: c_int = -107; +pub const UV_ENOTDIR: c_int = -20; +pub const UV_ENOTEMPTY: c_int = -39; +pub const UV_ENOTSOCK: c_int = -88; +pub const UV_ENOTSUP: c_int = -95; +pub const UV_EOVERFLOW: c_int = -75; +pub const UV_EPERM: c_int = -1; +pub const UV_EPIPE: c_int = -32; +pub const UV_EPROTO: c_int = -71; +pub const UV_EPROTONOSUPPORT: c_int = -93; +pub const UV_EPROTOTYPE: c_int = -91; +pub const UV_ERANGE: c_int = -34; +pub const UV_EROFS: c_int = -30; +pub const UV_ESHUTDOWN: c_int = -108; +pub const UV_ESPIPE: c_int = -29; +pub const UV_ESRCH: c_int = -3; +pub const UV_ETIMEDOUT: c_int = -110; +pub const UV_ETXTBSY: c_int = -26; +pub const UV_EXDEV: c_int = -18; +pub const UV_UNKNOWN: c_int = -4094; +pub const UV_EOF: c_int = -4095; +pub const UV_ENXIO: c_int = -6; +pub const UV_EMLINK: c_int = -31; +pub const UV_EHOSTDOWN: c_int = -112; +pub const UV_EREMOTEIO: c_int = -121; +pub const UV_ENOTTY: c_int = -25; +pub const UV_EFTYPE: c_int = -4028; +pub const UV_EILSEQ: c_int = -84; +pub const UV_ESOCKTNOSUPPORT: c_int = -94; +pub const UV_ERRNO_MAX: c_int = -4096; +pub const uv_errno_t = c_int; +pub const UV_UNKNOWN_HANDLE: c_int = 0; +pub const UV_ASYNC: c_int = 1; +pub const UV_CHECK: c_int = 2; +pub const UV_FS_EVENT: c_int = 3; +pub const UV_FS_POLL: c_int = 4; +pub const UV_HANDLE: c_int = 5; +pub const UV_IDLE: c_int = 6; +pub const UV_NAMED_PIPE: c_int = 7; +pub const UV_POLL: c_int = 8; +pub const UV_PREPARE: c_int = 9; +pub const UV_PROCESS: c_int = 10; +pub const UV_STREAM: c_int = 11; +pub const UV_TCP: c_int = 12; +pub const UV_TIMER: c_int = 13; +pub const UV_TTY: c_int = 14; +pub const UV_UDP: c_int = 15; +pub const UV_SIGNAL: c_int = 16; +pub const UV_FILE: c_int = 17; +pub const UV_HANDLE_TYPE_MAX: c_int = 18; +pub const uv_handle_type = c_uint; +pub const UV_UNKNOWN_REQ: c_int = 0; +pub const UV_REQ: c_int = 1; +pub const UV_CONNECT: c_int = 2; +pub const UV_WRITE: c_int = 3; +pub const UV_SHUTDOWN: c_int = 4; +pub const UV_UDP_SEND: c_int = 5; +pub const UV_FS: c_int = 6; +pub const UV_WORK: c_int = 7; +pub const UV_GETADDRINFO: c_int = 8; +pub const UV_GETNAMEINFO: c_int = 9; +pub const UV_RANDOM: c_int = 10; +pub const UV_REQ_TYPE_MAX: c_int = 11; +pub const uv_req_type = c_uint; +pub const struct_uv_dirent_s = extern struct { + name: [*c]const u8, + type: uv_dirent_type_t, +}; +pub const uv_dirent_t = struct_uv_dirent_s; +pub const struct_uv_dir_s = extern struct { + dirents: [*c]uv_dirent_t, + nentries: usize, + reserved: [4]?*anyopaque, + dir: ?*DIR, +}; +pub const uv_dir_t = struct_uv_dir_s; +const union_unnamed_91 = extern union { + fd: c_int, + reserved: [4]?*anyopaque, +}; +pub const uv_alloc_cb = ?*const fn ([*c]uv_handle_t, usize, [*c]uv_buf_t) callconv(.C) void; +pub const uv_stream_t = struct_uv_stream_s; +pub const uv_read_cb = ?*const fn ([*c]uv_stream_t, isize, [*c]const uv_buf_t) callconv(.C) void; +pub const uv_connect_cb = ?*const fn ([*c]uv_connect_t, c_int) callconv(.C) void; +pub const struct_uv_connect_s = extern struct { + data: ?*anyopaque, + type: uv_req_type, + reserved: [6]?*anyopaque, + cb: uv_connect_cb, + handle: [*c]uv_stream_t, + queue: [2]?*anyopaque, +}; +pub const uv_connect_t = struct_uv_connect_s; +pub const uv_shutdown_cb = ?*const fn ([*c]uv_shutdown_t, c_int) callconv(.C) void; +pub const struct_uv_shutdown_s = extern struct { + data: ?*anyopaque, + type: uv_req_type, + reserved: [6]?*anyopaque, + handle: [*c]uv_stream_t, + cb: uv_shutdown_cb, +}; +pub const uv_shutdown_t = struct_uv_shutdown_s; +pub const uv_connection_cb = ?*const fn ([*c]uv_stream_t, c_int) callconv(.C) void; +pub const struct_uv_stream_s = extern struct { + data: ?*anyopaque, + loop: [*c]uv_loop_t, + type: uv_handle_type, + close_cb: uv_close_cb, + handle_queue: [2]?*anyopaque, + u: union_unnamed_91, + next_closing: [*c]uv_handle_t, + flags: c_uint, + write_queue_size: usize, + alloc_cb: uv_alloc_cb, + read_cb: uv_read_cb, + connect_req: [*c]uv_connect_t, + shutdown_req: [*c]uv_shutdown_t, + io_watcher: uv__io_t, + write_queue: [2]?*anyopaque, + write_completed_queue: [2]?*anyopaque, + connection_cb: uv_connection_cb, + delayed_error: c_int, + accepted_fd: c_int, + queued_fds: ?*anyopaque, +}; +const union_unnamed_92 = extern union { + fd: c_int, + reserved: [4]?*anyopaque, +}; +pub const struct_uv_tcp_s = extern struct { + data: ?*anyopaque, + loop: [*c]uv_loop_t, + type: uv_handle_type, + close_cb: uv_close_cb, + handle_queue: [2]?*anyopaque, + u: union_unnamed_92, + next_closing: [*c]uv_handle_t, + flags: c_uint, + write_queue_size: usize, + alloc_cb: uv_alloc_cb, + read_cb: uv_read_cb, + connect_req: [*c]uv_connect_t, + shutdown_req: [*c]uv_shutdown_t, + io_watcher: uv__io_t, + write_queue: [2]?*anyopaque, + write_completed_queue: [2]?*anyopaque, + connection_cb: uv_connection_cb, + delayed_error: c_int, + accepted_fd: c_int, + queued_fds: ?*anyopaque, +}; +pub const uv_tcp_t = struct_uv_tcp_s; +const union_unnamed_93 = extern union { + fd: c_int, + reserved: [4]?*anyopaque, +}; +pub const uv_udp_t = struct_uv_udp_s; +pub const uv_udp_recv_cb = ?*const fn ([*c]uv_udp_t, isize, [*c]const uv_buf_t, [*c]const struct_sockaddr, c_uint) callconv(.C) void; +pub const struct_uv_udp_s = extern struct { + data: ?*anyopaque, + loop: [*c]uv_loop_t, + type: uv_handle_type, + close_cb: uv_close_cb, + handle_queue: [2]?*anyopaque, + u: union_unnamed_93, + next_closing: [*c]uv_handle_t, + flags: c_uint, + send_queue_size: usize, + send_queue_count: usize, + alloc_cb: uv_alloc_cb, + recv_cb: uv_udp_recv_cb, + io_watcher: uv__io_t, + write_queue: [2]?*anyopaque, + write_completed_queue: [2]?*anyopaque, +}; +const union_unnamed_94 = extern union { + fd: c_int, + reserved: [4]?*anyopaque, +}; +pub const struct_uv_pipe_s = extern struct { + data: ?*anyopaque, + loop: [*c]uv_loop_t, + type: uv_handle_type, + close_cb: uv_close_cb, + handle_queue: [2]?*anyopaque, + u: union_unnamed_94, + next_closing: [*c]uv_handle_t, + flags: c_uint, + write_queue_size: usize, + alloc_cb: uv_alloc_cb, + read_cb: uv_read_cb, + connect_req: [*c]uv_connect_t, + shutdown_req: [*c]uv_shutdown_t, + io_watcher: uv__io_t, + write_queue: [2]?*anyopaque, + write_completed_queue: [2]?*anyopaque, + connection_cb: uv_connection_cb, + delayed_error: c_int, + accepted_fd: c_int, + queued_fds: ?*anyopaque, + ipc: c_int, + pipe_fname: [*c]const u8, +}; +pub const uv_pipe_t = struct_uv_pipe_s; +const union_unnamed_95 = extern union { + fd: c_int, + reserved: [4]?*anyopaque, +}; +pub const struct_uv_tty_s = extern struct { + data: ?*anyopaque, + loop: [*c]uv_loop_t, + type: uv_handle_type, + close_cb: uv_close_cb, + handle_queue: [2]?*anyopaque, + u: union_unnamed_95, + next_closing: [*c]uv_handle_t, + flags: c_uint, + write_queue_size: usize, + alloc_cb: uv_alloc_cb, + read_cb: uv_read_cb, + connect_req: [*c]uv_connect_t, + shutdown_req: [*c]uv_shutdown_t, + io_watcher: uv__io_t, + write_queue: [2]?*anyopaque, + write_completed_queue: [2]?*anyopaque, + connection_cb: uv_connection_cb, + delayed_error: c_int, + accepted_fd: c_int, + queued_fds: ?*anyopaque, + orig_termios: struct_termios, + mode: c_int, +}; +pub const uv_tty_t = struct_uv_tty_s; +const union_unnamed_96 = extern union { + fd: c_int, + reserved: [4]?*anyopaque, +}; +pub const uv_poll_t = struct_uv_poll_s; +pub const uv_poll_cb = ?*const fn ([*c]uv_poll_t, c_int, c_int) callconv(.C) void; +pub const struct_uv_poll_s = extern struct { + data: ?*anyopaque, + loop: [*c]uv_loop_t, + type: uv_handle_type, + close_cb: uv_close_cb, + handle_queue: [2]?*anyopaque, + u: union_unnamed_96, + next_closing: [*c]uv_handle_t, + flags: c_uint, + poll_cb: uv_poll_cb, + io_watcher: uv__io_t, +}; +const union_unnamed_97 = extern union { + fd: c_int, + reserved: [4]?*anyopaque, +}; +pub const uv_timer_t = struct_uv_timer_s; +pub const uv_timer_cb = ?*const fn ([*c]uv_timer_t) callconv(.C) void; +pub const struct_uv_timer_s = extern struct { + data: ?*anyopaque, + loop: [*c]uv_loop_t, + type: uv_handle_type, + close_cb: uv_close_cb, + handle_queue: [2]?*anyopaque, + u: union_unnamed_97, + next_closing: [*c]uv_handle_t, + flags: c_uint, + timer_cb: uv_timer_cb, + heap_node: [3]?*anyopaque, + timeout: u64, + repeat: u64, + start_id: u64, +}; +const union_unnamed_98 = extern union { + fd: c_int, + reserved: [4]?*anyopaque, +}; +pub const uv_prepare_t = struct_uv_prepare_s; +pub const uv_prepare_cb = ?*const fn ([*c]uv_prepare_t) callconv(.C) void; +pub const struct_uv_prepare_s = extern struct { + data: ?*anyopaque, + loop: [*c]uv_loop_t, + type: uv_handle_type, + close_cb: uv_close_cb, + handle_queue: [2]?*anyopaque, + u: union_unnamed_98, + next_closing: [*c]uv_handle_t, + flags: c_uint, + prepare_cb: uv_prepare_cb, + queue: [2]?*anyopaque, +}; +const union_unnamed_99 = extern union { + fd: c_int, + reserved: [4]?*anyopaque, +}; +pub const uv_check_t = struct_uv_check_s; +pub const uv_check_cb = ?*const fn ([*c]uv_check_t) callconv(.C) void; +pub const struct_uv_check_s = extern struct { + data: ?*anyopaque, + loop: [*c]uv_loop_t, + type: uv_handle_type, + close_cb: uv_close_cb, + handle_queue: [2]?*anyopaque, + u: union_unnamed_99, + next_closing: [*c]uv_handle_t, + flags: c_uint, + check_cb: uv_check_cb, + queue: [2]?*anyopaque, +}; +const union_unnamed_100 = extern union { + fd: c_int, + reserved: [4]?*anyopaque, +}; +pub const uv_idle_t = struct_uv_idle_s; +pub const uv_idle_cb = ?*const fn ([*c]uv_idle_t) callconv(.C) void; +pub const struct_uv_idle_s = extern struct { + data: ?*anyopaque, + loop: [*c]uv_loop_t, + type: uv_handle_type, + close_cb: uv_close_cb, + handle_queue: [2]?*anyopaque, + u: union_unnamed_100, + next_closing: [*c]uv_handle_t, + flags: c_uint, + idle_cb: uv_idle_cb, + queue: [2]?*anyopaque, +}; +const union_unnamed_101 = extern union { + fd: c_int, + reserved: [4]?*anyopaque, +}; +pub const uv_process_t = struct_uv_process_s; +pub const uv_exit_cb = ?*const fn ([*c]uv_process_t, i64, c_int) callconv(.C) void; +pub const struct_uv_process_s = extern struct { + data: ?*anyopaque, + loop: [*c]uv_loop_t, + type: uv_handle_type, + close_cb: uv_close_cb, + handle_queue: [2]?*anyopaque, + u: union_unnamed_101, + next_closing: [*c]uv_handle_t, + flags: c_uint, + exit_cb: uv_exit_cb, + pid: c_int, + queue: [2]?*anyopaque, + status: c_int, +}; +const union_unnamed_102 = extern union { + fd: c_int, + reserved: [4]?*anyopaque, +}; +pub const uv_fs_event_t = struct_uv_fs_event_s; +pub const uv_fs_event_cb = ?*const fn ([*c]uv_fs_event_t, [*c]const u8, c_int, c_int) callconv(.C) void; +pub const struct_uv_fs_event_s = extern struct { + data: ?*anyopaque, + loop: [*c]uv_loop_t, + type: uv_handle_type, + close_cb: uv_close_cb, + handle_queue: [2]?*anyopaque, + u: union_unnamed_102, + next_closing: [*c]uv_handle_t, + flags: c_uint, + path: [*c]u8, + cb: uv_fs_event_cb, + watchers: [2]?*anyopaque, + wd: c_int, +}; +const union_unnamed_103 = extern union { + fd: c_int, + reserved: [4]?*anyopaque, +}; +pub const struct_uv_fs_poll_s = extern struct { + data: ?*anyopaque, + loop: [*c]uv_loop_t, + type: uv_handle_type, + close_cb: uv_close_cb, + handle_queue: [2]?*anyopaque, + u: union_unnamed_103, + next_closing: [*c]uv_handle_t, + flags: c_uint, + poll_ctx: ?*anyopaque, +}; +pub const uv_fs_poll_t = struct_uv_fs_poll_s; +pub const struct_uv_req_s = extern struct { + data: ?*anyopaque, + type: uv_req_type, + reserved: [6]?*anyopaque, +}; +pub const uv_req_t = struct_uv_req_s; +pub const uv_getaddrinfo_t = struct_uv_getaddrinfo_s; +pub const uv_getaddrinfo_cb = ?*const fn ([*c]uv_getaddrinfo_t, c_int, [*c]struct_addrinfo) callconv(.C) void; +pub const struct_uv_getaddrinfo_s = extern struct { + data: ?*anyopaque, + type: uv_req_type, + reserved: [6]?*anyopaque, + loop: [*c]uv_loop_t, + work_req: struct_uv__work, + cb: uv_getaddrinfo_cb, + hints: [*c]struct_addrinfo, + hostname: [*c]u8, + service: [*c]u8, + addrinfo: [*c]struct_addrinfo, + retcode: c_int, +}; +pub const uv_getnameinfo_t = struct_uv_getnameinfo_s; +pub const uv_getnameinfo_cb = ?*const fn ([*c]uv_getnameinfo_t, c_int, [*c]const u8, [*c]const u8) callconv(.C) void; +pub const struct_uv_getnameinfo_s = extern struct { + data: ?*anyopaque, + type: uv_req_type, + reserved: [6]?*anyopaque, + loop: [*c]uv_loop_t, + work_req: struct_uv__work, + getnameinfo_cb: uv_getnameinfo_cb, + storage: struct_sockaddr_storage, + flags: c_int, + host: [1025]u8, + service: [32]u8, + retcode: c_int, +}; +pub const uv_write_t = struct_uv_write_s; +pub const uv_write_cb = ?*const fn ([*c]uv_write_t, c_int) callconv(.C) void; +pub const struct_uv_write_s = extern struct { + data: ?*anyopaque, + type: uv_req_type, + reserved: [6]?*anyopaque, + cb: uv_write_cb, + send_handle: [*c]uv_stream_t, + handle: [*c]uv_stream_t, + queue: [2]?*anyopaque, + write_index: c_uint, + bufs: [*c]uv_buf_t, + nbufs: c_uint, + @"error": c_int, + bufsml: [4]uv_buf_t, +}; +pub const uv_udp_send_t = struct_uv_udp_send_s; +pub const uv_udp_send_cb = ?*const fn ([*c]uv_udp_send_t, c_int) callconv(.C) void; +pub const struct_uv_udp_send_s = extern struct { + data: ?*anyopaque, + type: uv_req_type, + reserved: [6]?*anyopaque, + handle: [*c]uv_udp_t, + cb: uv_udp_send_cb, + queue: [2]?*anyopaque, + addr: struct_sockaddr_storage, + nbufs: c_uint, + bufs: [*c]uv_buf_t, + status: isize, + send_cb: uv_udp_send_cb, + bufsml: [4]uv_buf_t, +}; +pub const uv_fs_t = struct_uv_fs_s; +pub const uv_fs_cb = ?*const fn ([*c]uv_fs_t) callconv(.C) void; +pub const struct_uv_fs_s = extern struct { + data: ?*anyopaque, + type: uv_req_type, + reserved: [6]?*anyopaque, + fs_type: uv_fs_type, + loop: [*c]uv_loop_t, + cb: uv_fs_cb, + result: isize, + ptr: ?*anyopaque, + path: [*c]const u8, + statbuf: uv_stat_t, + new_path: [*c]const u8, + file: uv_file, + flags: c_int, + mode: mode_t, + nbufs: c_uint, + bufs: [*c]uv_buf_t, + off: off_t, + uid: uv_uid_t, + gid: uv_gid_t, + atime: f64, + mtime: f64, + work_req: struct_uv__work, + bufsml: [4]uv_buf_t, +}; +pub const uv_work_t = struct_uv_work_s; +pub const uv_work_cb = ?*const fn ([*c]uv_work_t) callconv(.C) void; +pub const uv_after_work_cb = ?*const fn ([*c]uv_work_t, c_int) callconv(.C) void; +pub const struct_uv_work_s = extern struct { + data: ?*anyopaque, + type: uv_req_type, + reserved: [6]?*anyopaque, + loop: [*c]uv_loop_t, + work_cb: uv_work_cb, + after_work_cb: uv_after_work_cb, + work_req: struct_uv__work, +}; +pub const uv_random_t = struct_uv_random_s; +pub const uv_random_cb = ?*const fn ([*c]uv_random_t, c_int, ?*anyopaque, usize) callconv(.C) void; +pub const struct_uv_random_s = extern struct { + data: ?*anyopaque, + type: uv_req_type, + reserved: [6]?*anyopaque, + loop: [*c]uv_loop_t, + status: c_int, + buf: ?*anyopaque, + buflen: usize, + cb: uv_random_cb, + work_req: struct_uv__work, +}; +pub const struct_uv_env_item_s = extern struct { + name: [*c]u8, + value: [*c]u8, +}; +pub const uv_env_item_t = struct_uv_env_item_s; +pub const struct_uv_cpu_times_s = extern struct { + user: u64, + nice: u64, + sys: u64, + idle: u64, + irq: u64, +}; +pub const struct_uv_cpu_info_s = extern struct { + model: [*c]u8, + speed: c_int, + cpu_times: struct_uv_cpu_times_s, +}; +pub const uv_cpu_info_t = struct_uv_cpu_info_s; +const union_unnamed_104 = extern union { + address4: struct_sockaddr_in, + address6: struct_sockaddr_in6, +}; +const union_unnamed_105 = extern union { + netmask4: struct_sockaddr_in, + netmask6: struct_sockaddr_in6, +}; +pub const struct_uv_interface_address_s = extern struct { + name: [*c]u8, + phys_addr: [6]u8, + is_internal: c_int, + address: union_unnamed_104, + netmask: union_unnamed_105, +}; +pub const uv_interface_address_t = struct_uv_interface_address_s; +pub const struct_uv_passwd_s = extern struct { + username: [*c]u8, + uid: c_ulong, + gid: c_ulong, + shell: [*c]u8, + homedir: [*c]u8, +}; +pub const uv_passwd_t = struct_uv_passwd_s; +pub const struct_uv_utsname_s = extern struct { + sysname: [256]u8, + release: [256]u8, + version: [256]u8, + machine: [256]u8, +}; +pub const uv_utsname_t = struct_uv_utsname_s; +pub const struct_uv_statfs_s = extern struct { + f_type: u64, + f_bsize: u64, + f_blocks: u64, + f_bfree: u64, + f_bavail: u64, + f_files: u64, + f_ffree: u64, + f_spare: [4]u64, +}; +pub const uv_statfs_t = struct_uv_statfs_s; +pub const UV_LOOP_BLOCK_SIGNAL: c_int = 0; +pub const UV_METRICS_IDLE_TIME: c_int = 1; +pub const uv_loop_option = c_uint; +pub const UV_RUN_DEFAULT: c_int = 0; +pub const UV_RUN_ONCE: c_int = 1; +pub const UV_RUN_NOWAIT: c_int = 2; +pub const uv_run_mode = c_uint; +pub extern fn uv_version() c_uint; +pub extern fn uv_version_string() [*c]const u8; +pub const uv_malloc_func = ?*const fn (usize) callconv(.C) ?*anyopaque; +pub const uv_realloc_func = ?*const fn (?*anyopaque, usize) callconv(.C) ?*anyopaque; +pub const uv_calloc_func = ?*const fn (usize, usize) callconv(.C) ?*anyopaque; +pub const uv_free_func = ?*const fn (?*anyopaque) callconv(.C) void; +pub extern fn uv_library_shutdown() void; +pub extern fn uv_replace_allocator(malloc_func: uv_malloc_func, realloc_func: uv_realloc_func, calloc_func: uv_calloc_func, free_func: uv_free_func) c_int; +pub extern fn uv_default_loop() [*c]uv_loop_t; +pub extern fn uv_loop_init(loop: [*c]uv_loop_t) c_int; +pub extern fn uv_loop_close(loop: [*c]uv_loop_t) c_int; +pub extern fn uv_loop_new() [*c]uv_loop_t; +pub extern fn uv_loop_delete([*c]uv_loop_t) void; +pub extern fn uv_loop_size() usize; +pub extern fn uv_loop_alive(loop: [*c]const uv_loop_t) c_int; +pub extern fn uv_loop_configure(loop: [*c]uv_loop_t, option: uv_loop_option, ...) c_int; +pub extern fn uv_loop_fork(loop: [*c]uv_loop_t) c_int; +pub extern fn uv_run([*c]uv_loop_t, mode: uv_run_mode) c_int; +pub extern fn uv_stop([*c]uv_loop_t) void; +pub extern fn uv_ref([*c]uv_handle_t) void; +pub extern fn uv_unref([*c]uv_handle_t) void; +pub extern fn uv_has_ref([*c]const uv_handle_t) c_int; +pub extern fn uv_update_time([*c]uv_loop_t) void; +pub extern fn uv_now([*c]const uv_loop_t) u64; +pub extern fn uv_backend_fd([*c]const uv_loop_t) c_int; +pub extern fn uv_backend_timeout([*c]const uv_loop_t) c_int; +pub const uv_walk_cb = ?*const fn ([*c]uv_handle_t, ?*anyopaque) callconv(.C) void; +pub const uv_timespec_t = extern struct { + tv_sec: c_long, + tv_nsec: c_long, +}; +pub const uv_stat_t = extern struct { + st_dev: u64, + st_mode: u64, + st_nlink: u64, + st_uid: u64, + st_gid: u64, + st_rdev: u64, + st_ino: u64, + st_size: u64, + st_blksize: u64, + st_blocks: u64, + st_flags: u64, + st_gen: u64, + st_atim: uv_timespec_t, + st_mtim: uv_timespec_t, + st_ctim: uv_timespec_t, + st_birthtim: uv_timespec_t, +}; +pub const uv_fs_poll_cb = ?*const fn ([*c]uv_fs_poll_t, c_int, [*c]const uv_stat_t, [*c]const uv_stat_t) callconv(.C) void; +pub const UV_LEAVE_GROUP: c_int = 0; +pub const UV_JOIN_GROUP: c_int = 1; +pub const uv_membership = c_uint; +pub extern fn uv_translate_sys_error(sys_errno: c_int) c_int; +pub extern fn uv_strerror(err: c_int) [*c]const u8; +pub extern fn uv_strerror_r(err: c_int, buf: [*c]u8, buflen: usize) [*c]u8; +pub extern fn uv_err_name(err: c_int) [*c]const u8; +pub extern fn uv_err_name_r(err: c_int, buf: [*c]u8, buflen: usize) [*c]u8; +pub extern fn uv_shutdown(req: [*c]uv_shutdown_t, handle: [*c]uv_stream_t, cb: uv_shutdown_cb) c_int; +pub extern fn uv_handle_size(@"type": uv_handle_type) usize; +pub extern fn uv_handle_get_type(handle: [*c]const uv_handle_t) uv_handle_type; +pub extern fn uv_handle_type_name(@"type": uv_handle_type) [*c]const u8; +pub extern fn uv_handle_get_data(handle: [*c]const uv_handle_t) ?*anyopaque; +pub extern fn uv_handle_get_loop(handle: [*c]const uv_handle_t) [*c]uv_loop_t; +pub extern fn uv_handle_set_data(handle: [*c]uv_handle_t, data: ?*anyopaque) void; +pub extern fn uv_req_size(@"type": uv_req_type) usize; +pub extern fn uv_req_get_data(req: [*c]const uv_req_t) ?*anyopaque; +pub extern fn uv_req_set_data(req: [*c]uv_req_t, data: ?*anyopaque) void; +pub extern fn uv_req_get_type(req: [*c]const uv_req_t) uv_req_type; +pub extern fn uv_req_type_name(@"type": uv_req_type) [*c]const u8; +pub extern fn uv_is_active(handle: [*c]const uv_handle_t) c_int; +pub extern fn uv_walk(loop: [*c]uv_loop_t, walk_cb: uv_walk_cb, arg: ?*anyopaque) void; +pub extern fn uv_print_all_handles(loop: [*c]uv_loop_t, stream: [*c]FILE) void; +pub extern fn uv_print_active_handles(loop: [*c]uv_loop_t, stream: [*c]FILE) void; +pub extern fn uv_close(handle: [*c]uv_handle_t, close_cb: uv_close_cb) void; +pub extern fn uv_send_buffer_size(handle: [*c]uv_handle_t, value: [*c]c_int) c_int; +pub extern fn uv_recv_buffer_size(handle: [*c]uv_handle_t, value: [*c]c_int) c_int; +pub extern fn uv_fileno(handle: [*c]const uv_handle_t, fd: [*c]uv_os_fd_t) c_int; +pub extern fn uv_buf_init(base: [*c]u8, len: c_uint) uv_buf_t; +pub extern fn uv_pipe(fds: [*c]uv_file, read_flags: c_int, write_flags: c_int) c_int; +pub extern fn uv_socketpair(@"type": c_int, protocol: c_int, socket_vector: [*c]uv_os_sock_t, flags0: c_int, flags1: c_int) c_int; +pub extern fn uv_stream_get_write_queue_size(stream: [*c]const uv_stream_t) usize; +pub extern fn uv_listen(stream: [*c]uv_stream_t, backlog: c_int, cb: uv_connection_cb) c_int; +pub extern fn uv_accept(server: [*c]uv_stream_t, client: [*c]uv_stream_t) c_int; +pub extern fn uv_read_start([*c]uv_stream_t, alloc_cb: uv_alloc_cb, read_cb: uv_read_cb) c_int; +pub extern fn uv_read_stop([*c]uv_stream_t) c_int; +pub extern fn uv_write(req: [*c]uv_write_t, handle: [*c]uv_stream_t, bufs: [*c]const uv_buf_t, nbufs: c_uint, cb: uv_write_cb) c_int; +pub extern fn uv_write2(req: [*c]uv_write_t, handle: [*c]uv_stream_t, bufs: [*c]const uv_buf_t, nbufs: c_uint, send_handle: [*c]uv_stream_t, cb: uv_write_cb) c_int; +pub extern fn uv_try_write(handle: [*c]uv_stream_t, bufs: [*c]const uv_buf_t, nbufs: c_uint) c_int; +pub extern fn uv_try_write2(handle: [*c]uv_stream_t, bufs: [*c]const uv_buf_t, nbufs: c_uint, send_handle: [*c]uv_stream_t) c_int; +pub extern fn uv_is_readable(handle: [*c]const uv_stream_t) c_int; +pub extern fn uv_is_writable(handle: [*c]const uv_stream_t) c_int; +pub extern fn uv_stream_set_blocking(handle: [*c]uv_stream_t, blocking: c_int) c_int; +pub extern fn uv_is_closing(handle: [*c]const uv_handle_t) c_int; +pub extern fn uv_tcp_init([*c]uv_loop_t, handle: [*c]uv_tcp_t) c_int; +pub extern fn uv_tcp_init_ex([*c]uv_loop_t, handle: [*c]uv_tcp_t, flags: c_uint) c_int; +pub extern fn uv_tcp_open(handle: [*c]uv_tcp_t, sock: uv_os_sock_t) c_int; +pub extern fn uv_tcp_nodelay(handle: [*c]uv_tcp_t, enable: c_int) c_int; +pub extern fn uv_tcp_keepalive(handle: [*c]uv_tcp_t, enable: c_int, delay: c_uint) c_int; +pub extern fn uv_tcp_simultaneous_accepts(handle: [*c]uv_tcp_t, enable: c_int) c_int; +pub const UV_TCP_IPV6ONLY: c_int = 1; +pub const enum_uv_tcp_flags = c_uint; +pub extern fn uv_tcp_bind(handle: [*c]uv_tcp_t, addr: [*c]const struct_sockaddr, flags: c_uint) c_int; +pub extern fn uv_tcp_getsockname(handle: [*c]const uv_tcp_t, name: [*c]struct_sockaddr, namelen: [*c]c_int) c_int; +pub extern fn uv_tcp_getpeername(handle: [*c]const uv_tcp_t, name: [*c]struct_sockaddr, namelen: [*c]c_int) c_int; +pub extern fn uv_tcp_close_reset(handle: [*c]uv_tcp_t, close_cb: uv_close_cb) c_int; +pub extern fn uv_tcp_connect(req: [*c]uv_connect_t, handle: [*c]uv_tcp_t, addr: [*c]const struct_sockaddr, cb: uv_connect_cb) c_int; +pub const UV_UDP_IPV6ONLY: c_int = 1; +pub const UV_UDP_PARTIAL: c_int = 2; +pub const UV_UDP_REUSEADDR: c_int = 4; +pub const UV_UDP_MMSG_CHUNK: c_int = 8; +pub const UV_UDP_MMSG_FREE: c_int = 16; +pub const UV_UDP_LINUX_RECVERR: c_int = 32; +pub const UV_UDP_RECVMMSG: c_int = 256; +pub const enum_uv_udp_flags = c_uint; +pub extern fn uv_udp_init([*c]uv_loop_t, handle: [*c]uv_udp_t) c_int; +pub extern fn uv_udp_init_ex([*c]uv_loop_t, handle: [*c]uv_udp_t, flags: c_uint) c_int; +pub extern fn uv_udp_open(handle: [*c]uv_udp_t, sock: uv_os_sock_t) c_int; +pub extern fn uv_udp_bind(handle: [*c]uv_udp_t, addr: [*c]const struct_sockaddr, flags: c_uint) c_int; +pub extern fn uv_udp_connect(handle: [*c]uv_udp_t, addr: [*c]const struct_sockaddr) c_int; +pub extern fn uv_udp_getpeername(handle: [*c]const uv_udp_t, name: [*c]struct_sockaddr, namelen: [*c]c_int) c_int; +pub extern fn uv_udp_getsockname(handle: [*c]const uv_udp_t, name: [*c]struct_sockaddr, namelen: [*c]c_int) c_int; +pub extern fn uv_udp_set_membership(handle: [*c]uv_udp_t, multicast_addr: [*c]const u8, interface_addr: [*c]const u8, membership: uv_membership) c_int; +pub extern fn uv_udp_set_source_membership(handle: [*c]uv_udp_t, multicast_addr: [*c]const u8, interface_addr: [*c]const u8, source_addr: [*c]const u8, membership: uv_membership) c_int; +pub extern fn uv_udp_set_multicast_loop(handle: [*c]uv_udp_t, on: c_int) c_int; +pub extern fn uv_udp_set_multicast_ttl(handle: [*c]uv_udp_t, ttl: c_int) c_int; +pub extern fn uv_udp_set_multicast_interface(handle: [*c]uv_udp_t, interface_addr: [*c]const u8) c_int; +pub extern fn uv_udp_set_broadcast(handle: [*c]uv_udp_t, on: c_int) c_int; +pub extern fn uv_udp_set_ttl(handle: [*c]uv_udp_t, ttl: c_int) c_int; +pub extern fn uv_udp_send(req: [*c]uv_udp_send_t, handle: [*c]uv_udp_t, bufs: [*c]const uv_buf_t, nbufs: c_uint, addr: [*c]const struct_sockaddr, send_cb: uv_udp_send_cb) c_int; +pub extern fn uv_udp_try_send(handle: [*c]uv_udp_t, bufs: [*c]const uv_buf_t, nbufs: c_uint, addr: [*c]const struct_sockaddr) c_int; +pub extern fn uv_udp_recv_start(handle: [*c]uv_udp_t, alloc_cb: uv_alloc_cb, recv_cb: uv_udp_recv_cb) c_int; +pub extern fn uv_udp_using_recvmmsg(handle: [*c]const uv_udp_t) c_int; +pub extern fn uv_udp_recv_stop(handle: [*c]uv_udp_t) c_int; +pub extern fn uv_udp_get_send_queue_size(handle: [*c]const uv_udp_t) usize; +pub extern fn uv_udp_get_send_queue_count(handle: [*c]const uv_udp_t) usize; +pub const UV_TTY_MODE_NORMAL: c_int = 0; +pub const UV_TTY_MODE_RAW: c_int = 1; +pub const UV_TTY_MODE_IO: c_int = 2; +pub const uv_tty_mode_t = c_uint; +pub const UV_TTY_SUPPORTED: c_int = 0; +pub const UV_TTY_UNSUPPORTED: c_int = 1; +pub const uv_tty_vtermstate_t = c_uint; +pub extern fn uv_tty_init([*c]uv_loop_t, [*c]uv_tty_t, fd: uv_file, readable: c_int) c_int; +pub extern fn uv_tty_set_mode([*c]uv_tty_t, mode: uv_tty_mode_t) c_int; +pub extern fn uv_tty_reset_mode() c_int; +pub extern fn uv_tty_get_winsize([*c]uv_tty_t, width: [*c]c_int, height: [*c]c_int) c_int; +pub extern fn uv_tty_set_vterm_state(state: uv_tty_vtermstate_t) void; +pub extern fn uv_tty_get_vterm_state(state: [*c]uv_tty_vtermstate_t) c_int; +pub extern fn uv_guess_handle(file: uv_file) uv_handle_type; +pub extern fn uv_pipe_init([*c]uv_loop_t, handle: [*c]uv_pipe_t, ipc: c_int) c_int; +pub extern fn uv_pipe_open([*c]uv_pipe_t, file: uv_file) c_int; +pub extern fn uv_pipe_bind(handle: [*c]uv_pipe_t, name: [*c]const u8) c_int; +pub extern fn uv_pipe_connect(req: [*c]uv_connect_t, handle: [*c]uv_pipe_t, name: [*c]const u8, cb: uv_connect_cb) void; +pub extern fn uv_pipe_getsockname(handle: [*c]const uv_pipe_t, buffer: [*c]u8, size: [*c]usize) c_int; +pub extern fn uv_pipe_getpeername(handle: [*c]const uv_pipe_t, buffer: [*c]u8, size: [*c]usize) c_int; +pub extern fn uv_pipe_pending_instances(handle: [*c]uv_pipe_t, count: c_int) void; +pub extern fn uv_pipe_pending_count(handle: [*c]uv_pipe_t) c_int; +pub extern fn uv_pipe_pending_type(handle: [*c]uv_pipe_t) uv_handle_type; +pub extern fn uv_pipe_chmod(handle: [*c]uv_pipe_t, flags: c_int) c_int; +pub const UV_READABLE: c_int = 1; +pub const UV_WRITABLE: c_int = 2; +pub const UV_DISCONNECT: c_int = 4; +pub const UV_PRIORITIZED: c_int = 8; +pub const enum_uv_poll_event = c_uint; +pub extern fn uv_poll_init(loop: [*c]uv_loop_t, handle: [*c]uv_poll_t, fd: c_int) c_int; +pub extern fn uv_poll_init_socket(loop: [*c]uv_loop_t, handle: [*c]uv_poll_t, socket: uv_os_sock_t) c_int; +pub extern fn uv_poll_start(handle: [*c]uv_poll_t, events: c_int, cb: uv_poll_cb) c_int; +pub extern fn uv_poll_stop(handle: [*c]uv_poll_t) c_int; +pub extern fn uv_prepare_init([*c]uv_loop_t, prepare: [*c]uv_prepare_t) c_int; +pub extern fn uv_prepare_start(prepare: [*c]uv_prepare_t, cb: uv_prepare_cb) c_int; +pub extern fn uv_prepare_stop(prepare: [*c]uv_prepare_t) c_int; +pub extern fn uv_check_init([*c]uv_loop_t, check: [*c]uv_check_t) c_int; +pub extern fn uv_check_start(check: [*c]uv_check_t, cb: uv_check_cb) c_int; +pub extern fn uv_check_stop(check: [*c]uv_check_t) c_int; +pub extern fn uv_idle_init([*c]uv_loop_t, idle: [*c]uv_idle_t) c_int; +pub extern fn uv_idle_start(idle: [*c]uv_idle_t, cb: uv_idle_cb) c_int; +pub extern fn uv_idle_stop(idle: [*c]uv_idle_t) c_int; +pub extern fn uv_async_init([*c]uv_loop_t, @"async": [*c]uv_async_t, async_cb: uv_async_cb) c_int; +pub extern fn uv_async_send(@"async": [*c]uv_async_t) c_int; +pub extern fn uv_timer_init([*c]uv_loop_t, handle: [*c]uv_timer_t) c_int; +pub extern fn uv_timer_start(handle: [*c]uv_timer_t, cb: uv_timer_cb, timeout: u64, repeat: u64) c_int; +pub extern fn uv_timer_stop(handle: [*c]uv_timer_t) c_int; +pub extern fn uv_timer_again(handle: [*c]uv_timer_t) c_int; +pub extern fn uv_timer_set_repeat(handle: [*c]uv_timer_t, repeat: u64) void; +pub extern fn uv_timer_get_repeat(handle: [*c]const uv_timer_t) u64; +pub extern fn uv_timer_get_due_in(handle: [*c]const uv_timer_t) u64; +pub extern fn uv_getaddrinfo(loop: [*c]uv_loop_t, req: [*c]uv_getaddrinfo_t, getaddrinfo_cb: uv_getaddrinfo_cb, node: [*c]const u8, service: [*c]const u8, hints: [*c]const struct_addrinfo) c_int; +pub extern fn uv_freeaddrinfo(ai: [*c]struct_addrinfo) void; +pub extern fn uv_getnameinfo(loop: [*c]uv_loop_t, req: [*c]uv_getnameinfo_t, getnameinfo_cb: uv_getnameinfo_cb, addr: [*c]const struct_sockaddr, flags: c_int) c_int; +pub const UV_IGNORE: c_int = 0; +pub const UV_CREATE_PIPE: c_int = 1; +pub const UV_INHERIT_FD: c_int = 2; +pub const UV_INHERIT_STREAM: c_int = 4; +pub const UV_READABLE_PIPE: c_int = 16; +pub const UV_WRITABLE_PIPE: c_int = 32; +pub const UV_NONBLOCK_PIPE: c_int = 64; +pub const UV_OVERLAPPED_PIPE: c_int = 64; +pub const uv_stdio_flags = c_uint; +const union_unnamed_106 = extern union { + stream: [*c]uv_stream_t, + fd: c_int, +}; +pub const struct_uv_stdio_container_s = extern struct { + flags: uv_stdio_flags, + data: union_unnamed_106, +}; +pub const uv_stdio_container_t = struct_uv_stdio_container_s; +pub const struct_uv_process_options_s = extern struct { + exit_cb: uv_exit_cb, + file: [*c]const u8, + args: [*c][*c]u8, + env: [*c][*c]u8, + cwd: [*c]const u8, + flags: c_uint, + stdio_count: c_int, + stdio: [*c]uv_stdio_container_t, + uid: uv_uid_t, + gid: uv_gid_t, +}; +pub const uv_process_options_t = struct_uv_process_options_s; +pub const UV_PROCESS_SETUID: c_int = 1; +pub const UV_PROCESS_SETGID: c_int = 2; +pub const UV_PROCESS_WINDOWS_VERBATIM_ARGUMENTS: c_int = 4; +pub const UV_PROCESS_DETACHED: c_int = 8; +pub const UV_PROCESS_WINDOWS_HIDE: c_int = 16; +pub const UV_PROCESS_WINDOWS_HIDE_CONSOLE: c_int = 32; +pub const UV_PROCESS_WINDOWS_HIDE_GUI: c_int = 64; +pub const enum_uv_process_flags = c_uint; +pub extern fn uv_spawn(loop: [*c]uv_loop_t, handle: [*c]uv_process_t, options: [*c]const uv_process_options_t) c_int; +pub extern fn uv_process_kill([*c]uv_process_t, signum: c_int) c_int; +pub extern fn uv_kill(pid: c_int, signum: c_int) c_int; +pub extern fn uv_process_get_pid([*c]const uv_process_t) uv_pid_t; +pub extern fn uv_queue_work(loop: [*c]uv_loop_t, req: [*c]uv_work_t, work_cb: uv_work_cb, after_work_cb: uv_after_work_cb) c_int; +pub extern fn uv_cancel(req: [*c]uv_req_t) c_int; +pub const UV_DIRENT_UNKNOWN: c_int = 0; +pub const UV_DIRENT_FILE: c_int = 1; +pub const UV_DIRENT_DIR: c_int = 2; +pub const UV_DIRENT_LINK: c_int = 3; +pub const UV_DIRENT_FIFO: c_int = 4; +pub const UV_DIRENT_SOCKET: c_int = 5; +pub const UV_DIRENT_CHAR: c_int = 6; +pub const UV_DIRENT_BLOCK: c_int = 7; +pub const uv_dirent_type_t = c_uint; +pub extern fn uv_setup_args(argc: c_int, argv: [*c][*c]u8) [*c][*c]u8; +pub extern fn uv_get_process_title(buffer: [*c]u8, size: usize) c_int; +pub extern fn uv_set_process_title(title: [*c]const u8) c_int; +pub extern fn uv_resident_set_memory(rss: [*c]usize) c_int; +pub extern fn uv_uptime(uptime: [*c]f64) c_int; +pub extern fn uv_get_osfhandle(fd: c_int) uv_os_fd_t; +pub extern fn uv_open_osfhandle(os_fd: uv_os_fd_t) c_int; +pub const uv_timeval_t = extern struct { + tv_sec: c_long, + tv_usec: c_long, +}; +pub const uv_timeval64_t = extern struct { + tv_sec: i64, + tv_usec: i32, +}; +pub const uv_rusage_t = extern struct { + ru_utime: uv_timeval_t, + ru_stime: uv_timeval_t, + ru_maxrss: u64, + ru_ixrss: u64, + ru_idrss: u64, + ru_isrss: u64, + ru_minflt: u64, + ru_majflt: u64, + ru_nswap: u64, + ru_inblock: u64, + ru_oublock: u64, + ru_msgsnd: u64, + ru_msgrcv: u64, + ru_nsignals: u64, + ru_nvcsw: u64, + ru_nivcsw: u64, +}; +pub extern fn uv_getrusage(rusage: [*c]uv_rusage_t) c_int; +pub extern fn uv_os_homedir(buffer: [*c]u8, size: [*c]usize) c_int; +pub extern fn uv_os_tmpdir(buffer: [*c]u8, size: [*c]usize) c_int; +pub extern fn uv_os_get_passwd(pwd: [*c]uv_passwd_t) c_int; +pub extern fn uv_os_free_passwd(pwd: [*c]uv_passwd_t) void; +pub extern fn uv_os_getpid() uv_pid_t; +pub extern fn uv_os_getppid() uv_pid_t; +pub extern fn uv_os_getpriority(pid: uv_pid_t, priority: [*c]c_int) c_int; +pub extern fn uv_os_setpriority(pid: uv_pid_t, priority: c_int) c_int; +pub extern fn uv_available_parallelism() c_uint; +pub extern fn uv_cpu_info(cpu_infos: [*c][*c]uv_cpu_info_t, count: [*c]c_int) c_int; +pub extern fn uv_free_cpu_info(cpu_infos: [*c]uv_cpu_info_t, count: c_int) void; +pub extern fn uv_interface_addresses(addresses: [*c][*c]uv_interface_address_t, count: [*c]c_int) c_int; +pub extern fn uv_free_interface_addresses(addresses: [*c]uv_interface_address_t, count: c_int) void; +pub extern fn uv_os_environ(envitems: [*c][*c]uv_env_item_t, count: [*c]c_int) c_int; +pub extern fn uv_os_free_environ(envitems: [*c]uv_env_item_t, count: c_int) void; +pub extern fn uv_os_getenv(name: [*c]const u8, buffer: [*c]u8, size: [*c]usize) c_int; +pub extern fn uv_os_setenv(name: [*c]const u8, value: [*c]const u8) c_int; +pub extern fn uv_os_unsetenv(name: [*c]const u8) c_int; +pub extern fn uv_os_gethostname(buffer: [*c]u8, size: [*c]usize) c_int; +pub extern fn uv_os_uname(buffer: [*c]uv_utsname_t) c_int; +pub extern fn uv_metrics_idle_time(loop: [*c]uv_loop_t) u64; +pub const UV_FS_UNKNOWN: c_int = -1; +pub const UV_FS_CUSTOM: c_int = 0; +pub const UV_FS_OPEN: c_int = 1; +pub const UV_FS_CLOSE: c_int = 2; +pub const UV_FS_READ: c_int = 3; +pub const UV_FS_WRITE: c_int = 4; +pub const UV_FS_SENDFILE: c_int = 5; +pub const UV_FS_STAT: c_int = 6; +pub const UV_FS_LSTAT: c_int = 7; +pub const UV_FS_FSTAT: c_int = 8; +pub const UV_FS_FTRUNCATE: c_int = 9; +pub const UV_FS_UTIME: c_int = 10; +pub const UV_FS_FUTIME: c_int = 11; +pub const UV_FS_ACCESS: c_int = 12; +pub const UV_FS_CHMOD: c_int = 13; +pub const UV_FS_FCHMOD: c_int = 14; +pub const UV_FS_FSYNC: c_int = 15; +pub const UV_FS_FDATASYNC: c_int = 16; +pub const UV_FS_UNLINK: c_int = 17; +pub const UV_FS_RMDIR: c_int = 18; +pub const UV_FS_MKDIR: c_int = 19; +pub const UV_FS_MKDTEMP: c_int = 20; +pub const UV_FS_RENAME: c_int = 21; +pub const UV_FS_SCANDIR: c_int = 22; +pub const UV_FS_LINK: c_int = 23; +pub const UV_FS_SYMLINK: c_int = 24; +pub const UV_FS_READLINK: c_int = 25; +pub const UV_FS_CHOWN: c_int = 26; +pub const UV_FS_FCHOWN: c_int = 27; +pub const UV_FS_REALPATH: c_int = 28; +pub const UV_FS_COPYFILE: c_int = 29; +pub const UV_FS_LCHOWN: c_int = 30; +pub const UV_FS_OPENDIR: c_int = 31; +pub const UV_FS_READDIR: c_int = 32; +pub const UV_FS_CLOSEDIR: c_int = 33; +pub const UV_FS_STATFS: c_int = 34; +pub const UV_FS_MKSTEMP: c_int = 35; +pub const UV_FS_LUTIME: c_int = 36; +pub const uv_fs_type = c_int; +pub extern fn uv_fs_get_type([*c]const uv_fs_t) uv_fs_type; +pub extern fn uv_fs_get_result([*c]const uv_fs_t) isize; +pub extern fn uv_fs_get_system_error([*c]const uv_fs_t) c_int; +pub extern fn uv_fs_get_ptr([*c]const uv_fs_t) ?*anyopaque; +pub extern fn uv_fs_get_path([*c]const uv_fs_t) [*c]const u8; +pub extern fn uv_fs_get_statbuf([*c]uv_fs_t) [*c]uv_stat_t; +pub extern fn uv_fs_req_cleanup(req: [*c]uv_fs_t) void; +pub extern fn uv_fs_close(loop: [*c]uv_loop_t, req: [*c]uv_fs_t, file: uv_file, cb: uv_fs_cb) c_int; +pub extern fn uv_fs_open(loop: [*c]uv_loop_t, req: [*c]uv_fs_t, path: [*c]const u8, flags: c_int, mode: c_int, cb: uv_fs_cb) c_int; +pub extern fn uv_fs_read(loop: [*c]uv_loop_t, req: [*c]uv_fs_t, file: uv_file, bufs: [*c]const uv_buf_t, nbufs: c_uint, offset: i64, cb: uv_fs_cb) c_int; +pub extern fn uv_fs_unlink(loop: [*c]uv_loop_t, req: [*c]uv_fs_t, path: [*c]const u8, cb: uv_fs_cb) c_int; +pub extern fn uv_fs_write(loop: [*c]uv_loop_t, req: [*c]uv_fs_t, file: uv_file, bufs: [*c]const uv_buf_t, nbufs: c_uint, offset: i64, cb: uv_fs_cb) c_int; +pub extern fn uv_fs_copyfile(loop: [*c]uv_loop_t, req: [*c]uv_fs_t, path: [*c]const u8, new_path: [*c]const u8, flags: c_int, cb: uv_fs_cb) c_int; +pub extern fn uv_fs_mkdir(loop: [*c]uv_loop_t, req: [*c]uv_fs_t, path: [*c]const u8, mode: c_int, cb: uv_fs_cb) c_int; +pub extern fn uv_fs_mkdtemp(loop: [*c]uv_loop_t, req: [*c]uv_fs_t, tpl: [*c]const u8, cb: uv_fs_cb) c_int; +pub extern fn uv_fs_mkstemp(loop: [*c]uv_loop_t, req: [*c]uv_fs_t, tpl: [*c]const u8, cb: uv_fs_cb) c_int; +pub extern fn uv_fs_rmdir(loop: [*c]uv_loop_t, req: [*c]uv_fs_t, path: [*c]const u8, cb: uv_fs_cb) c_int; +pub extern fn uv_fs_scandir(loop: [*c]uv_loop_t, req: [*c]uv_fs_t, path: [*c]const u8, flags: c_int, cb: uv_fs_cb) c_int; +pub extern fn uv_fs_scandir_next(req: [*c]uv_fs_t, ent: [*c]uv_dirent_t) c_int; +pub extern fn uv_fs_opendir(loop: [*c]uv_loop_t, req: [*c]uv_fs_t, path: [*c]const u8, cb: uv_fs_cb) c_int; +pub extern fn uv_fs_readdir(loop: [*c]uv_loop_t, req: [*c]uv_fs_t, dir: [*c]uv_dir_t, cb: uv_fs_cb) c_int; +pub extern fn uv_fs_closedir(loop: [*c]uv_loop_t, req: [*c]uv_fs_t, dir: [*c]uv_dir_t, cb: uv_fs_cb) c_int; +pub extern fn uv_fs_stat(loop: [*c]uv_loop_t, req: [*c]uv_fs_t, path: [*c]const u8, cb: uv_fs_cb) c_int; +pub extern fn uv_fs_fstat(loop: [*c]uv_loop_t, req: [*c]uv_fs_t, file: uv_file, cb: uv_fs_cb) c_int; +pub extern fn uv_fs_rename(loop: [*c]uv_loop_t, req: [*c]uv_fs_t, path: [*c]const u8, new_path: [*c]const u8, cb: uv_fs_cb) c_int; +pub extern fn uv_fs_fsync(loop: [*c]uv_loop_t, req: [*c]uv_fs_t, file: uv_file, cb: uv_fs_cb) c_int; +pub extern fn uv_fs_fdatasync(loop: [*c]uv_loop_t, req: [*c]uv_fs_t, file: uv_file, cb: uv_fs_cb) c_int; +pub extern fn uv_fs_ftruncate(loop: [*c]uv_loop_t, req: [*c]uv_fs_t, file: uv_file, offset: i64, cb: uv_fs_cb) c_int; +pub extern fn uv_fs_sendfile(loop: [*c]uv_loop_t, req: [*c]uv_fs_t, out_fd: uv_file, in_fd: uv_file, in_offset: i64, length: usize, cb: uv_fs_cb) c_int; +pub extern fn uv_fs_access(loop: [*c]uv_loop_t, req: [*c]uv_fs_t, path: [*c]const u8, mode: c_int, cb: uv_fs_cb) c_int; +pub extern fn uv_fs_chmod(loop: [*c]uv_loop_t, req: [*c]uv_fs_t, path: [*c]const u8, mode: c_int, cb: uv_fs_cb) c_int; +pub extern fn uv_fs_utime(loop: [*c]uv_loop_t, req: [*c]uv_fs_t, path: [*c]const u8, atime: f64, mtime: f64, cb: uv_fs_cb) c_int; +pub extern fn uv_fs_futime(loop: [*c]uv_loop_t, req: [*c]uv_fs_t, file: uv_file, atime: f64, mtime: f64, cb: uv_fs_cb) c_int; +pub extern fn uv_fs_lutime(loop: [*c]uv_loop_t, req: [*c]uv_fs_t, path: [*c]const u8, atime: f64, mtime: f64, cb: uv_fs_cb) c_int; +pub extern fn uv_fs_lstat(loop: [*c]uv_loop_t, req: [*c]uv_fs_t, path: [*c]const u8, cb: uv_fs_cb) c_int; +pub extern fn uv_fs_link(loop: [*c]uv_loop_t, req: [*c]uv_fs_t, path: [*c]const u8, new_path: [*c]const u8, cb: uv_fs_cb) c_int; +pub extern fn uv_fs_symlink(loop: [*c]uv_loop_t, req: [*c]uv_fs_t, path: [*c]const u8, new_path: [*c]const u8, flags: c_int, cb: uv_fs_cb) c_int; +pub extern fn uv_fs_readlink(loop: [*c]uv_loop_t, req: [*c]uv_fs_t, path: [*c]const u8, cb: uv_fs_cb) c_int; +pub extern fn uv_fs_realpath(loop: [*c]uv_loop_t, req: [*c]uv_fs_t, path: [*c]const u8, cb: uv_fs_cb) c_int; +pub extern fn uv_fs_fchmod(loop: [*c]uv_loop_t, req: [*c]uv_fs_t, file: uv_file, mode: c_int, cb: uv_fs_cb) c_int; +pub extern fn uv_fs_chown(loop: [*c]uv_loop_t, req: [*c]uv_fs_t, path: [*c]const u8, uid: uv_uid_t, gid: uv_gid_t, cb: uv_fs_cb) c_int; +pub extern fn uv_fs_fchown(loop: [*c]uv_loop_t, req: [*c]uv_fs_t, file: uv_file, uid: uv_uid_t, gid: uv_gid_t, cb: uv_fs_cb) c_int; +pub extern fn uv_fs_lchown(loop: [*c]uv_loop_t, req: [*c]uv_fs_t, path: [*c]const u8, uid: uv_uid_t, gid: uv_gid_t, cb: uv_fs_cb) c_int; +pub extern fn uv_fs_statfs(loop: [*c]uv_loop_t, req: [*c]uv_fs_t, path: [*c]const u8, cb: uv_fs_cb) c_int; +pub const UV_RENAME: c_int = 1; +pub const UV_CHANGE: c_int = 2; +pub const enum_uv_fs_event = c_uint; +pub extern fn uv_fs_poll_init(loop: [*c]uv_loop_t, handle: [*c]uv_fs_poll_t) c_int; +pub extern fn uv_fs_poll_start(handle: [*c]uv_fs_poll_t, poll_cb: uv_fs_poll_cb, path: [*c]const u8, interval: c_uint) c_int; +pub extern fn uv_fs_poll_stop(handle: [*c]uv_fs_poll_t) c_int; +pub extern fn uv_fs_poll_getpath(handle: [*c]uv_fs_poll_t, buffer: [*c]u8, size: [*c]usize) c_int; +pub extern fn uv_signal_init(loop: [*c]uv_loop_t, handle: [*c]uv_signal_t) c_int; +pub extern fn uv_signal_start(handle: [*c]uv_signal_t, signal_cb: uv_signal_cb, signum: c_int) c_int; +pub extern fn uv_signal_start_oneshot(handle: [*c]uv_signal_t, signal_cb: uv_signal_cb, signum: c_int) c_int; +pub extern fn uv_signal_stop(handle: [*c]uv_signal_t) c_int; +pub extern fn uv_loadavg(avg: [*c]f64) void; +pub const UV_FS_EVENT_WATCH_ENTRY: c_int = 1; +pub const UV_FS_EVENT_STAT: c_int = 2; +pub const UV_FS_EVENT_RECURSIVE: c_int = 4; +pub const enum_uv_fs_event_flags = c_uint; +pub extern fn uv_fs_event_init(loop: [*c]uv_loop_t, handle: [*c]uv_fs_event_t) c_int; +pub extern fn uv_fs_event_start(handle: [*c]uv_fs_event_t, cb: uv_fs_event_cb, path: [*c]const u8, flags: c_uint) c_int; +pub extern fn uv_fs_event_stop(handle: [*c]uv_fs_event_t) c_int; +pub extern fn uv_fs_event_getpath(handle: [*c]uv_fs_event_t, buffer: [*c]u8, size: [*c]usize) c_int; +pub extern fn uv_ip4_addr(ip: [*c]const u8, port: c_int, addr: [*c]struct_sockaddr_in) c_int; +pub extern fn uv_ip6_addr(ip: [*c]const u8, port: c_int, addr: [*c]struct_sockaddr_in6) c_int; +pub extern fn uv_ip4_name(src: [*c]const struct_sockaddr_in, dst: [*c]u8, size: usize) c_int; +pub extern fn uv_ip6_name(src: [*c]const struct_sockaddr_in6, dst: [*c]u8, size: usize) c_int; +pub extern fn uv_ip_name(src: [*c]const struct_sockaddr, dst: [*c]u8, size: usize) c_int; +pub extern fn uv_inet_ntop(af: c_int, src: ?*const anyopaque, dst: [*c]u8, size: usize) c_int; +pub extern fn uv_inet_pton(af: c_int, src: [*c]const u8, dst: ?*anyopaque) c_int; +pub extern fn uv_random(loop: [*c]uv_loop_t, req: [*c]uv_random_t, buf: ?*anyopaque, buflen: usize, flags: c_uint, cb: uv_random_cb) c_int; +pub extern fn uv_if_indextoname(ifindex: c_uint, buffer: [*c]u8, size: [*c]usize) c_int; +pub extern fn uv_if_indextoiid(ifindex: c_uint, buffer: [*c]u8, size: [*c]usize) c_int; +pub extern fn uv_exepath(buffer: [*c]u8, size: [*c]usize) c_int; +pub extern fn uv_cwd(buffer: [*c]u8, size: [*c]usize) c_int; +pub extern fn uv_chdir(dir: [*c]const u8) c_int; +pub extern fn uv_get_free_memory() u64; +pub extern fn uv_get_total_memory() u64; +pub extern fn uv_get_constrained_memory() u64; +pub extern fn uv_hrtime() u64; +pub extern fn uv_sleep(msec: c_uint) void; +pub extern fn uv_disable_stdio_inheritance() void; +pub extern fn uv_dlopen(filename: [*c]const u8, lib: [*c]uv_lib_t) c_int; +pub extern fn uv_dlclose(lib: [*c]uv_lib_t) void; +pub extern fn uv_dlsym(lib: [*c]uv_lib_t, name: [*c]const u8, ptr: [*c]?*anyopaque) c_int; +pub extern fn uv_dlerror(lib: [*c]const uv_lib_t) [*c]const u8; +pub extern fn uv_mutex_init(handle: [*c]uv_mutex_t) c_int; +pub extern fn uv_mutex_init_recursive(handle: [*c]uv_mutex_t) c_int; +pub extern fn uv_mutex_destroy(handle: [*c]uv_mutex_t) void; +pub extern fn uv_mutex_lock(handle: [*c]uv_mutex_t) void; +pub extern fn uv_mutex_trylock(handle: [*c]uv_mutex_t) c_int; +pub extern fn uv_mutex_unlock(handle: [*c]uv_mutex_t) void; +pub extern fn uv_rwlock_init(rwlock: [*c]uv_rwlock_t) c_int; +pub extern fn uv_rwlock_destroy(rwlock: [*c]uv_rwlock_t) void; +pub extern fn uv_rwlock_rdlock(rwlock: [*c]uv_rwlock_t) void; +pub extern fn uv_rwlock_tryrdlock(rwlock: [*c]uv_rwlock_t) c_int; +pub extern fn uv_rwlock_rdunlock(rwlock: [*c]uv_rwlock_t) void; +pub extern fn uv_rwlock_wrlock(rwlock: [*c]uv_rwlock_t) void; +pub extern fn uv_rwlock_trywrlock(rwlock: [*c]uv_rwlock_t) c_int; +pub extern fn uv_rwlock_wrunlock(rwlock: [*c]uv_rwlock_t) void; +pub extern fn uv_sem_init(sem: [*c]uv_sem_t, value: c_uint) c_int; +pub extern fn uv_sem_destroy(sem: [*c]uv_sem_t) void; +pub extern fn uv_sem_post(sem: [*c]uv_sem_t) void; +pub extern fn uv_sem_wait(sem: [*c]uv_sem_t) void; +pub extern fn uv_sem_trywait(sem: [*c]uv_sem_t) c_int; +pub extern fn uv_cond_init(cond: [*c]uv_cond_t) c_int; +pub extern fn uv_cond_destroy(cond: [*c]uv_cond_t) void; +pub extern fn uv_cond_signal(cond: [*c]uv_cond_t) void; +pub extern fn uv_cond_broadcast(cond: [*c]uv_cond_t) void; +pub extern fn uv_barrier_init(barrier: [*c]uv_barrier_t, count: c_uint) c_int; +pub extern fn uv_barrier_destroy(barrier: [*c]uv_barrier_t) void; +pub extern fn uv_barrier_wait(barrier: [*c]uv_barrier_t) c_int; +pub extern fn uv_cond_wait(cond: [*c]uv_cond_t, mutex: [*c]uv_mutex_t) void; +pub extern fn uv_cond_timedwait(cond: [*c]uv_cond_t, mutex: [*c]uv_mutex_t, timeout: u64) c_int; +pub extern fn uv_once(guard: [*c]uv_once_t, callback: ?*const fn () callconv(.C) void) void; +pub extern fn uv_key_create(key: [*c]uv_key_t) c_int; +pub extern fn uv_key_delete(key: [*c]uv_key_t) void; +pub extern fn uv_key_get(key: [*c]uv_key_t) ?*anyopaque; +pub extern fn uv_key_set(key: [*c]uv_key_t, value: ?*anyopaque) void; +pub extern fn uv_gettimeofday(tv: [*c]uv_timeval64_t) c_int; +pub const uv_thread_cb = ?*const fn (?*anyopaque) callconv(.C) void; +pub extern fn uv_thread_create(tid: [*c]uv_thread_t, entry: uv_thread_cb, arg: ?*anyopaque) c_int; +pub const UV_THREAD_NO_FLAGS: c_int = 0; +pub const UV_THREAD_HAS_STACK_SIZE: c_int = 1; +pub const uv_thread_create_flags = c_uint; +pub const struct_uv_thread_options_s = extern struct { + flags: c_uint, + stack_size: usize, +}; +pub const uv_thread_options_t = struct_uv_thread_options_s; +pub extern fn uv_thread_create_ex(tid: [*c]uv_thread_t, params: [*c]const uv_thread_options_t, entry: uv_thread_cb, arg: ?*anyopaque) c_int; +pub extern fn uv_thread_self() uv_thread_t; +pub extern fn uv_thread_join(tid: [*c]uv_thread_t) c_int; +pub extern fn uv_thread_equal(t1: [*c]const uv_thread_t, t2: [*c]const uv_thread_t) c_int; +pub const union_uv_any_handle = extern union { + @"async": uv_async_t, + check: uv_check_t, + fs_event: uv_fs_event_t, + fs_poll: uv_fs_poll_t, + handle: uv_handle_t, + idle: uv_idle_t, + pipe: uv_pipe_t, + poll: uv_poll_t, + prepare: uv_prepare_t, + process: uv_process_t, + stream: uv_stream_t, + tcp: uv_tcp_t, + timer: uv_timer_t, + tty: uv_tty_t, + udp: uv_udp_t, + signal: uv_signal_t, +}; +pub const union_uv_any_req = extern union { + req: uv_req_t, + connect: uv_connect_t, + write: uv_write_t, + shutdown: uv_shutdown_t, + udp_send: uv_udp_send_t, + fs: uv_fs_t, + work: uv_work_t, + getaddrinfo: uv_getaddrinfo_t, + getnameinfo: uv_getnameinfo_t, + random: uv_random_t, +}; +pub extern fn uv_loop_get_data([*c]const uv_loop_t) ?*anyopaque; +pub extern fn uv_loop_set_data([*c]uv_loop_t, data: ?*anyopaque) void; +pub const FileInfo = extern struct { + stat: uv_stat_t, +}; +pub const FileID = extern struct { + inode: u64, + device_id: u64, +}; +pub const Directory = extern struct { + request: uv_fs_t, + ent: uv_dirent_t, +}; +pub const OPTION_MAGIC_NOT_SET: c_int = 0; +pub const OPTION_MAGIC_ON: c_int = 1; +pub const OPTION_MAGIC_OFF: c_int = 2; +pub const optmagic_T = c_uint; +pub const MAGIC_NONE: c_int = 1; +pub const MAGIC_OFF: c_int = 2; +pub const MAGIC_ON: c_int = 3; +pub const MAGIC_ALL: c_int = 4; +pub const magic_T = c_uint; +pub const regengine_T = struct_regengine; +pub const struct_regprog = extern struct { + engine: [*c]regengine_T, + regflags: c_uint, + re_engine: c_uint, + re_flags: c_uint, + re_in_use: bool, +}; +pub const regprog_T = struct_regprog; +pub const struct_regengine = extern struct { + regcomp: ?*const fn ([*c]u8, c_int) callconv(.C) [*c]regprog_T, + regfree: ?*const fn ([*c]regprog_T) callconv(.C) void, + regexec_nl: ?*const fn ([*c]regmatch_T, [*c]u8, colnr_T, bool) callconv(.C) c_int, + regexec_multi: ?*const fn ([*c]regmmatch_T, [*c]win_T, [*c]buf_T, linenr_T, colnr_T, [*c]proftime_T, [*c]c_int) callconv(.C) c_long, +}; +pub const struct_reg_extmatch = extern struct { + refcnt: i16, + matches: [10][*c]u8, +}; +pub const reg_extmatch_T = struct_reg_extmatch; +pub const regmmatch_T = extern struct { + regprog: [*c]regprog_T, + startpos: [10]lpos_T, + endpos: [10]lpos_T, + rmm_matchcol: colnr_T, + rmm_ic: c_int, + rmm_maxcol: colnr_T, +}; +pub const bt_regprog_T = extern struct { + engine: [*c]regengine_T align(8), + regflags: c_uint, + re_engine: c_uint, + re_flags: c_uint, + re_in_use: bool, + regstart: c_int, + reganch: u8, + regmust: [*c]u8, + regmlen: c_int, + reghasz: u8, + pub fn program(self: anytype) @import("std").zig.c_translation.FlexibleArrayType(@TypeOf(self), u8) { + const Intermediate = @import("std").zig.c_translation.FlexibleArrayType(@TypeOf(self), u8); + const ReturnType = @import("std").zig.c_translation.FlexibleArrayType(@TypeOf(self), u8); + return @ptrCast(ReturnType, @alignCast(@alignOf(u8), @ptrCast(Intermediate, self) + 45)); + } +}; +pub const nfa_state_T = struct_nfa_state; +pub const struct_nfa_state = extern struct { + c: c_int, + out: [*c]nfa_state_T, + out1: [*c]nfa_state_T, + id: c_int, + lastlist: [2]c_int, + val: c_int, +}; +pub const nfa_regprog_T = extern struct { + engine: [*c]regengine_T align(8), + regflags: c_uint, + re_engine: c_uint, + re_flags: c_uint, + re_in_use: bool, + start: [*c]nfa_state_T, + reganch: c_int, + regstart: c_int, + match_text: [*c]u8, + has_zend: c_int, + has_backref: c_int, + reghasz: c_int, + pattern: [*c]u8, + nsubexp: c_int, + nstate: c_int, + pub fn state(self: anytype) @import("std").zig.c_translation.FlexibleArrayType(@TypeOf(self), nfa_state_T) { + const Intermediate = @import("std").zig.c_translation.FlexibleArrayType(@TypeOf(self), u8); + const ReturnType = @import("std").zig.c_translation.FlexibleArrayType(@TypeOf(self), nfa_state_T); + return @ptrCast(ReturnType, @alignCast(@alignOf(nfa_state_T), @ptrCast(Intermediate, self) + 80)); + } +}; +pub const regmatch_T = extern struct { + regprog: [*c]regprog_T, + startp: [10][*c]u8, + endp: [10][*c]u8, + rm_matchcol: colnr_T, + rm_ic: bool, +}; +pub const synstate_T = struct_syn_state; +pub const struct_buf_state = extern struct { + bs_idx: c_int, + bs_flags: c_int, + bs_seqnr: c_int, + bs_cchar: c_int, + bs_extmatch: [*c]reg_extmatch_T, +}; +pub const bufstate_T = struct_buf_state; +const union_unnamed_107 = extern union { + sst_stack: [7]bufstate_T, + sst_ga: garray_T, +}; +pub const struct_syn_state = extern struct { + sst_next: [*c]synstate_T, + sst_lnum: linenr_T, + sst_union: union_unnamed_107, + sst_next_flags: c_int, + sst_stacksize: c_int, + sst_next_list: [*c]i16, + sst_tick: disptick_T, + sst_change_lnum: linenr_T, +}; +pub const struct_sp_syn = extern struct { + inc_tag: c_int, + id: i16, + cont_in_list: [*c]i16, +}; +pub const keyentry_T = struct_keyentry; +pub const struct_keyentry = extern struct { + ke_next: [*c]keyentry_T align(8), + k_syn: struct_sp_syn, + next_list: [*c]i16, + flags: c_int, + k_char: c_int, + pub fn keyword(self: anytype) @import("std").zig.c_translation.FlexibleArrayType(@TypeOf(self), u8) { + const Intermediate = @import("std").zig.c_translation.FlexibleArrayType(@TypeOf(self), u8); + const ReturnType = @import("std").zig.c_translation.FlexibleArrayType(@TypeOf(self), u8); + return @ptrCast(ReturnType, @alignCast(@alignOf(u8), @ptrCast(Intermediate, self) + 40)); + } +}; +pub const terminal_write_cb = ?*const fn ([*c]u8, usize, ?*anyopaque) callconv(.C) void; +pub const terminal_resize_cb = ?*const fn (u16, u16, ?*anyopaque) callconv(.C) void; +pub const terminal_close_cb = ?*const fn (?*anyopaque) callconv(.C) void; +pub const TerminalOptions = extern struct { + data: ?*anyopaque, + width: u16, + height: u16, + write_cb: terminal_write_cb, + resize_cb: terminal_resize_cb, + close_cb: terminal_close_cb, +}; +pub extern fn terminal_init() void; +pub extern fn terminal_teardown() void; +pub extern fn terminal_open(buf: [*c]buf_T, opts: TerminalOptions) ?*Terminal; +pub extern fn terminal_close(termpp: [*c]?*Terminal, status: c_int) void; +pub extern fn terminal_check_size(term: ?*Terminal) void; +pub extern fn terminal_enter() bool; +pub extern fn terminal_destroy(termpp: [*c]?*Terminal) void; +pub extern fn terminal_send(term: ?*Terminal, data: [*c]u8, size: usize) void; +pub extern fn terminal_paste(count: c_long, y_array: [*c][*c]u8, y_size: usize) void; +pub extern fn terminal_send_key(term: ?*Terminal, c: c_int) void; +pub extern fn terminal_receive(term: ?*Terminal, data: [*c]u8, len: usize) void; +pub extern fn terminal_get_line_attributes(term: ?*Terminal, wp: [*c]win_T, linenr: c_int, term_attrs: [*c]c_int) void; +pub extern fn terminal_buf(term: ?*const Terminal) Buffer; +pub extern fn terminal_running(term: ?*const Terminal) bool; +pub extern fn on_scrollback_option_changed(term: ?*Terminal) void; +pub const buffblock_T = struct_buffblock; +pub const struct_buffblock = extern struct { + b_next: [*c]buffblock_T, + b_str: [1]u8, +}; +pub const struct_buffheader = extern struct { + bh_first: buffblock_T, + bh_curr: [*c]buffblock_T, + bh_index: usize, + bh_space: usize, +}; +pub const buffheader_T = struct_buffheader; +pub const save_redo_T = extern struct { + sr_redobuff: buffheader_T, + sr_old_redobuff: buffheader_T, +}; +pub const winopt_T = extern struct { + wo_arab: c_int, + wo_bri: c_int, + wo_briopt: [*c]u8, + wo_diff: c_int, + wo_fdc: [*c]u8, + wo_fdc_save: [*c]u8, + wo_fen: c_int, + wo_fen_save: c_int, + wo_fdi: [*c]u8, + wo_fdl: c_long, + wo_fdl_save: c_long, + wo_fdm: [*c]u8, + wo_fdm_save: [*c]u8, + wo_fml: c_long, + wo_fdn: c_long, + wo_fde: [*c]u8, + wo_fdt: [*c]u8, + wo_fmr: [*c]u8, + wo_lbr: c_int, + wo_list: c_int, + wo_nu: c_int, + wo_rnu: c_int, + wo_ve: [*c]u8, + wo_ve_flags: c_uint, + wo_nuw: c_long, + wo_wfh: c_int, + wo_wfw: c_int, + wo_pvw: c_int, + wo_rl: c_int, + wo_rlc: [*c]u8, + wo_scr: c_long, + wo_spell: c_int, + wo_cuc: c_int, + wo_cul: c_int, + wo_culopt: [*c]u8, + wo_cc: [*c]u8, + wo_sbr: [*c]u8, + wo_stc: [*c]u8, + wo_stl: [*c]u8, + wo_wbr: [*c]u8, + wo_scb: c_int, + wo_diff_saved: c_int, + wo_scb_save: c_int, + wo_wrap: c_int, + wo_wrap_save: c_int, + wo_cocu: [*c]u8, + wo_cole: c_long, + wo_crb: c_int, + wo_crb_save: c_int, + wo_scl: [*c]u8, + wo_winhl: [*c]u8, + wo_lcs: [*c]u8, + wo_fcs: [*c]u8, + wo_winbl: c_long, + wo_script_ctx: [47]LastSet, +}; +pub const struct_argentry = extern struct { + ae_fname: [*c]u8, + ae_fnum: c_int, +}; +pub const aentry_T = struct_argentry; +pub const typebuf_T = extern struct { + tb_buf: [*c]u8, + tb_noremap: [*c]u8, + tb_buflen: c_int, + tb_off: c_int, + tb_len: c_int, + tb_maplen: c_int, + tb_silent: c_int, + tb_no_abbr_cnt: c_int, + tb_change_cnt: c_int, +}; +pub const tasave_T = extern struct { + save_typebuf: typebuf_T, + typebuf_valid: bool, + old_char: c_int, + old_mod_mask: c_int, + save_readbuf1: buffheader_T, + save_readbuf2: buffheader_T, + save_inputbuf: String, +}; +pub const syn_time_T = extern struct { + total: proftime_T, + slowest: proftime_T, + count: c_long, + match: c_long, +}; +pub const synblock_T = extern struct { + b_keywtab: hashtab_T, + b_keywtab_ic: hashtab_T, + b_syn_error: bool, + b_syn_slow: bool, + b_syn_ic: c_int, + b_syn_foldlevel: c_int, + b_syn_spell: c_int, + b_syn_patterns: garray_T, + b_syn_clusters: garray_T, + b_spell_cluster_id: c_int, + b_nospell_cluster_id: c_int, + b_syn_containedin: c_int, + b_syn_sync_flags: c_int, + b_syn_sync_id: i16, + b_syn_sync_minlines: linenr_T, + b_syn_sync_maxlines: linenr_T, + b_syn_sync_linebreaks: linenr_T, + b_syn_linecont_pat: [*c]u8, + b_syn_linecont_prog: [*c]regprog_T, + b_syn_linecont_time: syn_time_T, + b_syn_linecont_ic: c_int, + b_syn_topgrp: c_int, + b_syn_conceal: c_int, + b_syn_folditems: c_int, + b_sst_array: [*c]synstate_T, + b_sst_len: c_int, + b_sst_first: [*c]synstate_T, + b_sst_firstfree: [*c]synstate_T, + b_sst_freecount: c_int, + b_sst_check_lnum: linenr_T, + b_sst_lasttick: disptick_T, + b_langp: garray_T, + b_spell_ismw: [256]bool, + b_spell_ismw_mb: [*c]u8, + b_p_spc: [*c]u8, + b_cap_prog: [*c]regprog_T, + b_p_spf: [*c]u8, + b_p_spl: [*c]u8, + b_p_spo: [*c]u8, + b_p_spo_flags: c_uint, + b_cjk: c_int, + b_syn_chartab: [32]u8, + b_syn_isk: [*c]u8, +}; +pub const ChangedtickDictItem = extern struct { + di_tv: typval_T, + di_flags: u8, + di_key: [12]u8, +}; +pub const BufUpdateCallbacks = extern struct { + on_lines: LuaRef, + on_bytes: LuaRef, + on_changedtick: LuaRef, + on_detach: LuaRef, + on_reload: LuaRef, + utf_sizes: bool, + preview: bool, +}; +pub extern var curbuf_splice_pending: c_int; +pub const diff_T = struct_diffblock_S; +pub const struct_diffblock_S = extern struct { + df_next: [*c]diff_T, + df_lnum: [8]linenr_T, + df_count: [8]linenr_T, + is_linematched: bool, +}; +pub const tabpage_T = struct_tabpage_S; +pub const struct_tabpage_S = extern struct { + handle: handle_T, + tp_next: [*c]tabpage_T, + tp_topframe: [*c]frame_T, + tp_curwin: [*c]win_T, + tp_prevwin: [*c]win_T, + tp_firstwin: [*c]win_T, + tp_lastwin: [*c]win_T, + tp_old_Rows_avail: c_long, + tp_old_Columns: c_long, + tp_ch_used: c_long, + tp_first_diff: [*c]diff_T, + tp_diffbuf: [8][*c]buf_T, + tp_diff_invalid: c_int, + tp_diff_update: c_int, + tp_snapshot: [2][*c]frame_T, + tp_winvar: ScopeDictDictItem, + tp_vars: [*c]dict_T, + tp_localdir: [*c]u8, + tp_prevdir: [*c]u8, +}; +pub const match_T = extern struct { + rm: regmmatch_T, + buf: [*c]buf_T, + lnum: linenr_T, + attr: c_int, + attr_cur: c_int, + first_lnum: linenr_T, + startcol: colnr_T, + endcol: colnr_T, + is_addpos: bool, + has_cursor: bool, + tm: proftime_T, +}; +pub const llpos_T = extern struct { + lnum: linenr_T, + col: colnr_T, + len: c_int, +}; +pub const FloatAnchor = c_int; +pub const kFloatAnchorEast: c_int = 1; +pub const kFloatAnchorSouth: c_int = 2; +const enum_unnamed_108 = c_uint; +pub const float_anchor_str: [*c]const [*c]const u8 = @extern([*c]const [*c]const u8, .{ + .name = "float_anchor_str", +}); +pub const kFloatRelativeEditor: c_int = 0; +pub const kFloatRelativeWindow: c_int = 1; +pub const kFloatRelativeCursor: c_int = 2; +pub const kFloatRelativeMouse: c_int = 3; +pub const FloatRelative = c_uint; +pub const float_relative_str: [*c]const [*c]const u8 = @extern([*c]const [*c]const u8, .{ + .name = "float_relative_str", +}); +pub const kWinStyleUnused: c_int = 0; +pub const kWinStyleMinimal: c_int = 1; +pub const WinStyle = c_uint; +pub const kAlignLeft: c_int = 0; +pub const kAlignCenter: c_int = 1; +pub const kAlignRight: c_int = 2; +pub const AlignTextPos = c_uint; +pub const FloatConfig = extern struct { + window: Window, + bufpos: lpos_T, + height: c_int, + width: c_int, + row: f64, + col: f64, + anchor: FloatAnchor, + relative: FloatRelative, + external: bool, + focusable: bool, + zindex: c_int, + style: WinStyle, + border: bool, + title: bool, + shadow: bool, + border_chars: [8]schar_T, + border_hl_ids: [8]c_int, + border_attr: [8]c_int, + title_pos: AlignTextPos, + title_chunks: VirtText, + title_width: c_int, + noautocmd: bool, +}; +pub const pos_save_T = extern struct { + w_topline_save: c_int, + w_topline_corr: c_int, + w_cursor_save: pos_T, + w_cursor_corr: pos_T, +}; +pub extern fn nvim_buf_line_count(buffer: Buffer, err: [*c]Error) Integer; +pub extern fn nvim_buf_attach(channel_id: u64, buffer: Buffer, send_buffer: Boolean, opts: Dictionary, err: [*c]Error) Boolean; +pub extern fn nvim_buf_detach(channel_id: u64, buffer: Buffer, err: [*c]Error) Boolean; +pub extern fn nvim__buf_redraw_range(buffer: Buffer, first: Integer, last: Integer, err: [*c]Error) void; +pub extern fn nvim_buf_get_lines(channel_id: u64, buffer: Buffer, start: Integer, end: Integer, strict_indexing: Boolean, lstate: ?*lua_State, err: [*c]Error) Array; +pub extern fn nvim_buf_set_lines(channel_id: u64, buffer: Buffer, start: Integer, end: Integer, strict_indexing: Boolean, replacement: Array, err: [*c]Error) void; +pub extern fn nvim_buf_set_text(channel_id: u64, buffer: Buffer, start_row: Integer, start_col: Integer, end_row: Integer, end_col: Integer, replacement: Array, err: [*c]Error) void; +pub extern fn nvim_buf_get_text(channel_id: u64, buffer: Buffer, start_row: Integer, start_col: Integer, end_row: Integer, end_col: Integer, opts: Dictionary, lstate: ?*lua_State, err: [*c]Error) Array; +pub extern fn nvim_buf_get_offset(buffer: Buffer, index: Integer, err: [*c]Error) Integer; +pub extern fn nvim_buf_get_var(buffer: Buffer, name: String, err: [*c]Error) Object; +pub extern fn nvim_buf_get_changedtick(buffer: Buffer, err: [*c]Error) Integer; +pub extern fn nvim_buf_get_keymap(buffer: Buffer, mode: String, err: [*c]Error) Array; +pub extern fn nvim_buf_set_keymap(channel_id: u64, buffer: Buffer, mode: String, lhs: String, rhs: String, opts: [*c]KeyDict_keymap, err: [*c]Error) void; +pub extern fn nvim_buf_del_keymap(channel_id: u64, buffer: Buffer, mode: String, lhs: String, err: [*c]Error) void; +pub extern fn nvim_buf_set_var(buffer: Buffer, name: String, value: Object, err: [*c]Error) void; +pub extern fn nvim_buf_del_var(buffer: Buffer, name: String, err: [*c]Error) void; +pub extern fn nvim_buf_get_name(buffer: Buffer, arena: [*c]Arena, err: [*c]Error) String; +pub extern fn nvim_buf_set_name(buffer: Buffer, name: String, err: [*c]Error) void; +pub extern fn nvim_buf_is_loaded(buffer: Buffer) Boolean; +pub extern fn nvim_buf_delete(buffer: Buffer, opts: Dictionary, err: [*c]Error) void; +pub extern fn nvim_buf_is_valid(buffer: Buffer) Boolean; +pub extern fn nvim_buf_del_mark(buffer: Buffer, name: String, err: [*c]Error) Boolean; +pub extern fn nvim_buf_set_mark(buffer: Buffer, name: String, line: Integer, col: Integer, opts: Dictionary, err: [*c]Error) Boolean; +pub extern fn nvim_buf_get_mark(buffer: Buffer, name: String, err: [*c]Error) Array; +pub extern fn nvim_buf_call(buffer: Buffer, fun: LuaRef, err: [*c]Error) Object; +pub extern fn nvim__buf_stats(buffer: Buffer, err: [*c]Error) Dictionary; +pub extern fn buf_collect_lines(buf: [*c]buf_T, n: usize, start: linenr_T, start_idx: c_int, replace_nl: bool, l: [*c]Array, lstate: ?*lua_State, err: [*c]Error) bool; +pub const kVTEndOfLine: c_int = 0; +pub const kVTOverlay: c_int = 1; +pub const kVTWinCol: c_int = 2; +pub const kVTRightAlign: c_int = 3; +pub const VirtTextPos = c_uint; +pub const virt_text_pos_str: [*c]const [*c]const u8 = @extern([*c]const [*c]const u8, .{ + .name = "virt_text_pos_str", +}); +pub const kHlModeUnknown: c_int = 0; +pub const kHlModeReplace: c_int = 1; +pub const kHlModeCombine: c_int = 2; +pub const kHlModeBlend: c_int = 3; +pub const HlMode = c_uint; +pub const hl_mode_str: [*c]const [*c]const u8 = @extern([*c]const [*c]const u8, .{ + .name = "hl_mode_str", +}); +pub const struct_virt_line = extern struct { + line: VirtText, + left_col: bool, +}; +pub const VirtLines = extern struct { + size: usize, + capacity: usize, + items: [*c]struct_virt_line, +}; +pub const DecorRange = extern struct { + start_row: c_int, + start_col: c_int, + end_row: c_int, + end_col: c_int, + decor: Decoration, + attr_id: c_int, + virt_text_owned: bool, + win_col: c_int, + ns_id: u64, + mark_id: u64, +}; +const struct_unnamed_109 = extern struct { + size: usize, + capacity: usize, + items: [*c]DecorRange, +}; +pub const DecorState = extern struct { + itr: [1]MarkTreeIter, + active: struct_unnamed_109, + win: [*c]win_T, + top_row: c_int, + row: c_int, + col_until: c_int, + current: c_int, + eol_col: c_int, + conceal: bool, + conceal_char: c_int, + conceal_attr: c_int, + spell: TriState, +}; +pub extern var decor_state: DecorState; +pub fn decor_has_sign(arg_decor: [*c]Decoration) callconv(.C) bool { + var decor = arg_decor; + return ((((decor.*.sign_text != null) or (decor.*.sign_hl_id != 0)) or (decor.*.number_hl_id != 0)) or (decor.*.line_hl_id != 0)) or (decor.*.cursorline_hl_id != 0); +} +pub extern fn bufhl_add_hl_pos_offset(buf: [*c]buf_T, src_id: c_int, hl_id: c_int, pos_start: lpos_T, pos_end: lpos_T, offset: colnr_T) void; +pub extern fn decor_redraw(buf: [*c]buf_T, row1: c_int, row2: c_int, decor: [*c]Decoration) void; +pub extern fn decor_remove(buf: [*c]buf_T, row: c_int, row2: c_int, decor: [*c]Decoration) void; +pub extern fn decor_clear(decor: [*c]Decoration) void; +pub extern fn decor_free(decor: [*c]Decoration) void; +pub extern fn decor_state_free(state: [*c]DecorState) void; +pub extern fn clear_virttext(text: [*c]VirtText) void; +pub extern fn decor_find_virttext(buf: [*c]buf_T, row: c_int, ns_id: u64) [*c]Decoration; +pub extern fn decor_redraw_reset(wp: [*c]win_T, state: [*c]DecorState) bool; +pub extern fn get_decor(mark: mtkey_t) Decoration; +pub extern fn decor_redraw_start(wp: [*c]win_T, top_row: c_int, state: [*c]DecorState) bool; +pub extern fn decor_redraw_line(wp: [*c]win_T, row: c_int, state: [*c]DecorState) bool; +pub extern fn decor_redraw_col(wp: [*c]win_T, col: c_int, win_col: c_int, hidden: bool, state: [*c]DecorState) c_int; +pub extern fn decor_redraw_signs(buf: [*c]buf_T, row: c_int, num_signs: [*c]c_int, sattrs: [*c]SignTextAttrs, num_id: [*c]HlPriId, line_id: [*c]HlPriId, cul_id: [*c]HlPriId) void; +pub extern fn decor_signcols(buf: [*c]buf_T, state: [*c]DecorState, row: c_int, end_row: c_int, max: c_int) c_int; +pub extern fn decor_redraw_end(state: [*c]DecorState) void; +pub extern fn decor_redraw_eol(wp: [*c]win_T, state: [*c]DecorState, eol_attr: [*c]c_int, eol_col: c_int) bool; +pub extern fn decor_add_ephemeral(start_row: c_int, start_col: c_int, end_row: c_int, end_col: c_int, decor: [*c]Decoration, ns_id: u64, mark_id: u64) void; +pub extern fn decor_virt_lines(wp: [*c]win_T, lnum: linenr_T, lines: [*c]VirtLines, has_fold: TriState) c_int; +pub const kMTCharWise: c_int = 0; +pub const kMTLineWise: c_int = 1; +pub const kMTBlockWise: c_int = 2; +pub const kMTUnknown: c_int = -1; +pub const MotionType = c_int; +pub const struct_oparg_S = extern struct { + op_type: c_int, + regname: c_int, + motion_type: MotionType, + motion_force: c_int, + use_reg_one: bool, + inclusive: bool, + end_adjusted: bool, + start: pos_T, + end: pos_T, + cursor_start: pos_T, + line_count: c_long, + empty: bool, + is_VIsual: bool, + start_vcol: colnr_T, + end_vcol: colnr_T, + prev_opcount: c_long, + prev_count0: c_long, + excl_tr_ws: bool, +}; +pub const oparg_T = struct_oparg_S; +pub const struct_cmdarg_S = extern struct { + oap: [*c]oparg_T, + prechar: c_int, + cmdchar: c_int, + nchar: c_int, + ncharC1: c_int, + ncharC2: c_int, + extra_char: c_int, + opcount: c_long, + count0: c_long, + count1: c_long, + arg: c_int, + retval: c_int, + searchbuf: [*c]u8, +}; +pub const cmdarg_T = struct_cmdarg_S; +pub extern var showcmd_buf: [41]u8; +pub extern fn init_normal_cmds() void; +pub extern fn check_text_or_curbuf_locked(oap: [*c]oparg_T) bool; +pub extern fn normal_enter(cmdwin: bool, noexmode: bool) void; +pub extern fn end_visual_mode() void; +pub extern fn reset_VIsual_and_resel() void; +pub extern fn reset_VIsual() void; +pub extern fn restore_visual_mode() void; +pub extern fn find_ident_under_cursor(text: [*c][*c]u8, find_type: c_int) usize; +pub extern fn find_ident_at_pos(wp: [*c]win_T, lnum: linenr_T, startcol: colnr_T, text: [*c][*c]u8, textcol: [*c]c_int, find_type: c_int) usize; +pub extern fn prep_redo(regname: c_int, num: c_long, cmd1: c_int, cmd2: c_int, cmd3: c_int, cmd4: c_int, cmd5: c_int) void; +pub extern fn prep_redo_num2(regname: c_int, num1: c_long, cmd1: c_int, cmd2: c_int, num2: c_long, cmd3: c_int, cmd4: c_int, cmd5: c_int) void; +pub extern fn clearop(oap: [*c]oparg_T) void; +pub extern fn clearopbeep(oap: [*c]oparg_T) void; +pub extern fn may_clear_cmdline() void; +pub extern fn clear_showcmd() void; +pub extern fn add_to_showcmd(c: c_int) bool; +pub extern fn add_to_showcmd_c(c: c_int) void; +pub extern fn push_showcmd() void; +pub extern fn pop_showcmd() void; +pub extern fn do_check_scrollbind(check: bool) void; +pub extern fn check_scrollbind(topline_diff: linenr_T, leftcol_diff: c_long) void; +pub extern fn find_decl(ptr: [*c]u8, len: usize, locally: bool, thisblock: bool, flags_arg: c_int) bool; +pub extern fn scroll_redraw(up: c_int, count: c_long) void; +pub extern fn do_nv_ident(c1: c_int, c2: c_int) void; +pub extern fn get_visual_text(cap: [*c]cmdarg_T, pp: [*c][*c]u8, lenp: [*c]usize) bool; +pub extern fn start_selection() void; +pub extern fn may_start_select(c: c_int) void; +pub extern fn unadjust_for_sel() bool; +pub extern fn set_cursor_for_append_to_line() void; +pub extern fn normal_cmd(oap: [*c]oparg_T, toplevel: bool) void; +pub const CMD_append: c_int = 0; +pub const CMD_abbreviate: c_int = 1; +pub const CMD_abclear: c_int = 2; +pub const CMD_aboveleft: c_int = 3; +pub const CMD_all: c_int = 4; +pub const CMD_amenu: c_int = 5; +pub const CMD_anoremenu: c_int = 6; +pub const CMD_args: c_int = 7; +pub const CMD_argadd: c_int = 8; +pub const CMD_argdelete: c_int = 9; +pub const CMD_argdo: c_int = 10; +pub const CMD_argdedupe: c_int = 11; +pub const CMD_argedit: c_int = 12; +pub const CMD_argglobal: c_int = 13; +pub const CMD_arglocal: c_int = 14; +pub const CMD_argument: c_int = 15; +pub const CMD_ascii: c_int = 16; +pub const CMD_autocmd: c_int = 17; +pub const CMD_augroup: c_int = 18; +pub const CMD_aunmenu: c_int = 19; +pub const CMD_buffer: c_int = 20; +pub const CMD_bNext: c_int = 21; +pub const CMD_ball: c_int = 22; +pub const CMD_badd: c_int = 23; +pub const CMD_balt: c_int = 24; +pub const CMD_bdelete: c_int = 25; +pub const CMD_belowright: c_int = 26; +pub const CMD_bfirst: c_int = 27; +pub const CMD_blast: c_int = 28; +pub const CMD_bmodified: c_int = 29; +pub const CMD_bnext: c_int = 30; +pub const CMD_botright: c_int = 31; +pub const CMD_bprevious: c_int = 32; +pub const CMD_brewind: c_int = 33; +pub const CMD_break: c_int = 34; +pub const CMD_breakadd: c_int = 35; +pub const CMD_breakdel: c_int = 36; +pub const CMD_breaklist: c_int = 37; +pub const CMD_browse: c_int = 38; +pub const CMD_buffers: c_int = 39; +pub const CMD_bufdo: c_int = 40; +pub const CMD_bunload: c_int = 41; +pub const CMD_bwipeout: c_int = 42; +pub const CMD_change: c_int = 43; +pub const CMD_cNext: c_int = 44; +pub const CMD_cNfile: c_int = 45; +pub const CMD_cabbrev: c_int = 46; +pub const CMD_cabclear: c_int = 47; +pub const CMD_cabove: c_int = 48; +pub const CMD_caddbuffer: c_int = 49; +pub const CMD_caddexpr: c_int = 50; +pub const CMD_caddfile: c_int = 51; +pub const CMD_cafter: c_int = 52; +pub const CMD_call: c_int = 53; +pub const CMD_catch: c_int = 54; +pub const CMD_cbuffer: c_int = 55; +pub const CMD_cbefore: c_int = 56; +pub const CMD_cbelow: c_int = 57; +pub const CMD_cbottom: c_int = 58; +pub const CMD_cc: c_int = 59; +pub const CMD_cclose: c_int = 60; +pub const CMD_cd: c_int = 61; +pub const CMD_cdo: c_int = 62; +pub const CMD_center: c_int = 63; +pub const CMD_cexpr: c_int = 64; +pub const CMD_cfile: c_int = 65; +pub const CMD_cfdo: c_int = 66; +pub const CMD_cfirst: c_int = 67; +pub const CMD_cgetfile: c_int = 68; +pub const CMD_cgetbuffer: c_int = 69; +pub const CMD_cgetexpr: c_int = 70; +pub const CMD_chdir: c_int = 71; +pub const CMD_changes: c_int = 72; +pub const CMD_checkhealth: c_int = 73; +pub const CMD_checkpath: c_int = 74; +pub const CMD_checktime: c_int = 75; +pub const CMD_chistory: c_int = 76; +pub const CMD_clist: c_int = 77; +pub const CMD_clast: c_int = 78; +pub const CMD_close: c_int = 79; +pub const CMD_clearjumps: c_int = 80; +pub const CMD_cmap: c_int = 81; +pub const CMD_cmapclear: c_int = 82; +pub const CMD_cmenu: c_int = 83; +pub const CMD_cnext: c_int = 84; +pub const CMD_cnewer: c_int = 85; +pub const CMD_cnfile: c_int = 86; +pub const CMD_cnoremap: c_int = 87; +pub const CMD_cnoreabbrev: c_int = 88; +pub const CMD_cnoremenu: c_int = 89; +pub const CMD_copy: c_int = 90; +pub const CMD_colder: c_int = 91; +pub const CMD_colorscheme: c_int = 92; +pub const CMD_command: c_int = 93; +pub const CMD_comclear: c_int = 94; +pub const CMD_compiler: c_int = 95; +pub const CMD_continue: c_int = 96; +pub const CMD_confirm: c_int = 97; +pub const CMD_const: c_int = 98; +pub const CMD_copen: c_int = 99; +pub const CMD_cprevious: c_int = 100; +pub const CMD_cpfile: c_int = 101; +pub const CMD_cquit: c_int = 102; +pub const CMD_crewind: c_int = 103; +pub const CMD_cunmap: c_int = 104; +pub const CMD_cunabbrev: c_int = 105; +pub const CMD_cunmenu: c_int = 106; +pub const CMD_cwindow: c_int = 107; +pub const CMD_delete: c_int = 108; +pub const CMD_delmarks: c_int = 109; +pub const CMD_debug: c_int = 110; +pub const CMD_debuggreedy: c_int = 111; +pub const CMD_defer: c_int = 112; +pub const CMD_delcommand: c_int = 113; +pub const CMD_delfunction: c_int = 114; +pub const CMD_display: c_int = 115; +pub const CMD_diffupdate: c_int = 116; +pub const CMD_diffget: c_int = 117; +pub const CMD_diffoff: c_int = 118; +pub const CMD_diffpatch: c_int = 119; +pub const CMD_diffput: c_int = 120; +pub const CMD_diffsplit: c_int = 121; +pub const CMD_diffthis: c_int = 122; +pub const CMD_digraphs: c_int = 123; +pub const CMD_djump: c_int = 124; +pub const CMD_dlist: c_int = 125; +pub const CMD_doautocmd: c_int = 126; +pub const CMD_doautoall: c_int = 127; +pub const CMD_drop: c_int = 128; +pub const CMD_dsearch: c_int = 129; +pub const CMD_dsplit: c_int = 130; +pub const CMD_edit: c_int = 131; +pub const CMD_earlier: c_int = 132; +pub const CMD_echo: c_int = 133; +pub const CMD_echoerr: c_int = 134; +pub const CMD_echohl: c_int = 135; +pub const CMD_echomsg: c_int = 136; +pub const CMD_echon: c_int = 137; +pub const CMD_else: c_int = 138; +pub const CMD_elseif: c_int = 139; +pub const CMD_emenu: c_int = 140; +pub const CMD_endif: c_int = 141; +pub const CMD_endfunction: c_int = 142; +pub const CMD_endfor: c_int = 143; +pub const CMD_endtry: c_int = 144; +pub const CMD_endwhile: c_int = 145; +pub const CMD_enew: c_int = 146; +pub const CMD_eval: c_int = 147; +pub const CMD_ex: c_int = 148; +pub const CMD_execute: c_int = 149; +pub const CMD_exit: c_int = 150; +pub const CMD_exusage: c_int = 151; +pub const CMD_file: c_int = 152; +pub const CMD_files: c_int = 153; +pub const CMD_filetype: c_int = 154; +pub const CMD_filter: c_int = 155; +pub const CMD_find: c_int = 156; +pub const CMD_finally: c_int = 157; +pub const CMD_finish: c_int = 158; +pub const CMD_first: c_int = 159; +pub const CMD_fold: c_int = 160; +pub const CMD_foldclose: c_int = 161; +pub const CMD_folddoopen: c_int = 162; +pub const CMD_folddoclosed: c_int = 163; +pub const CMD_foldopen: c_int = 164; +pub const CMD_for: c_int = 165; +pub const CMD_function: c_int = 166; +pub const CMD_global: c_int = 167; +pub const CMD_goto: c_int = 168; +pub const CMD_grep: c_int = 169; +pub const CMD_grepadd: c_int = 170; +pub const CMD_gui: c_int = 171; +pub const CMD_gvim: c_int = 172; +pub const CMD_help: c_int = 173; +pub const CMD_helpclose: c_int = 174; +pub const CMD_helpgrep: c_int = 175; +pub const CMD_helptags: c_int = 176; +pub const CMD_highlight: c_int = 177; +pub const CMD_hide: c_int = 178; +pub const CMD_history: c_int = 179; +pub const CMD_horizontal: c_int = 180; +pub const CMD_insert: c_int = 181; +pub const CMD_iabbrev: c_int = 182; +pub const CMD_iabclear: c_int = 183; +pub const CMD_if: c_int = 184; +pub const CMD_ijump: c_int = 185; +pub const CMD_ilist: c_int = 186; +pub const CMD_imap: c_int = 187; +pub const CMD_imapclear: c_int = 188; +pub const CMD_imenu: c_int = 189; +pub const CMD_inoremap: c_int = 190; +pub const CMD_inoreabbrev: c_int = 191; +pub const CMD_inoremenu: c_int = 192; +pub const CMD_intro: c_int = 193; +pub const CMD_isearch: c_int = 194; +pub const CMD_isplit: c_int = 195; +pub const CMD_iunmap: c_int = 196; +pub const CMD_iunabbrev: c_int = 197; +pub const CMD_iunmenu: c_int = 198; +pub const CMD_join: c_int = 199; +pub const CMD_jumps: c_int = 200; +pub const CMD_k: c_int = 201; +pub const CMD_keepmarks: c_int = 202; +pub const CMD_keepjumps: c_int = 203; +pub const CMD_keeppatterns: c_int = 204; +pub const CMD_keepalt: c_int = 205; +pub const CMD_list: c_int = 206; +pub const CMD_lNext: c_int = 207; +pub const CMD_lNfile: c_int = 208; +pub const CMD_last: c_int = 209; +pub const CMD_labove: c_int = 210; +pub const CMD_language: c_int = 211; +pub const CMD_laddexpr: c_int = 212; +pub const CMD_laddbuffer: c_int = 213; +pub const CMD_laddfile: c_int = 214; +pub const CMD_lafter: c_int = 215; +pub const CMD_later: c_int = 216; +pub const CMD_lbuffer: c_int = 217; +pub const CMD_lbefore: c_int = 218; +pub const CMD_lbelow: c_int = 219; +pub const CMD_lbottom: c_int = 220; +pub const CMD_lcd: c_int = 221; +pub const CMD_lchdir: c_int = 222; +pub const CMD_lclose: c_int = 223; +pub const CMD_ldo: c_int = 224; +pub const CMD_left: c_int = 225; +pub const CMD_leftabove: c_int = 226; +pub const CMD_let: c_int = 227; +pub const CMD_lexpr: c_int = 228; +pub const CMD_lfile: c_int = 229; +pub const CMD_lfdo: c_int = 230; +pub const CMD_lfirst: c_int = 231; +pub const CMD_lgetfile: c_int = 232; +pub const CMD_lgetbuffer: c_int = 233; +pub const CMD_lgetexpr: c_int = 234; +pub const CMD_lgrep: c_int = 235; +pub const CMD_lgrepadd: c_int = 236; +pub const CMD_lhelpgrep: c_int = 237; +pub const CMD_lhistory: c_int = 238; +pub const CMD_ll: c_int = 239; +pub const CMD_llast: c_int = 240; +pub const CMD_llist: c_int = 241; +pub const CMD_lmap: c_int = 242; +pub const CMD_lmapclear: c_int = 243; +pub const CMD_lmake: c_int = 244; +pub const CMD_lnoremap: c_int = 245; +pub const CMD_lnext: c_int = 246; +pub const CMD_lnewer: c_int = 247; +pub const CMD_lnfile: c_int = 248; +pub const CMD_loadview: c_int = 249; +pub const CMD_loadkeymap: c_int = 250; +pub const CMD_lockmarks: c_int = 251; +pub const CMD_lockvar: c_int = 252; +pub const CMD_lolder: c_int = 253; +pub const CMD_lopen: c_int = 254; +pub const CMD_lprevious: c_int = 255; +pub const CMD_lpfile: c_int = 256; +pub const CMD_lrewind: c_int = 257; +pub const CMD_ltag: c_int = 258; +pub const CMD_lunmap: c_int = 259; +pub const CMD_lua: c_int = 260; +pub const CMD_luado: c_int = 261; +pub const CMD_luafile: c_int = 262; +pub const CMD_lvimgrep: c_int = 263; +pub const CMD_lvimgrepadd: c_int = 264; +pub const CMD_lwindow: c_int = 265; +pub const CMD_ls: c_int = 266; +pub const CMD_move: c_int = 267; +pub const CMD_mark: c_int = 268; +pub const CMD_make: c_int = 269; +pub const CMD_map: c_int = 270; +pub const CMD_mapclear: c_int = 271; +pub const CMD_marks: c_int = 272; +pub const CMD_match: c_int = 273; +pub const CMD_menu: c_int = 274; +pub const CMD_menutranslate: c_int = 275; +pub const CMD_messages: c_int = 276; +pub const CMD_mkexrc: c_int = 277; +pub const CMD_mksession: c_int = 278; +pub const CMD_mkspell: c_int = 279; +pub const CMD_mkvimrc: c_int = 280; +pub const CMD_mkview: c_int = 281; +pub const CMD_mode: c_int = 282; +pub const CMD_mzscheme: c_int = 283; +pub const CMD_mzfile: c_int = 284; +pub const CMD_next: c_int = 285; +pub const CMD_new: c_int = 286; +pub const CMD_nmap: c_int = 287; +pub const CMD_nmapclear: c_int = 288; +pub const CMD_nmenu: c_int = 289; +pub const CMD_nnoremap: c_int = 290; +pub const CMD_nnoremenu: c_int = 291; +pub const CMD_noremap: c_int = 292; +pub const CMD_noautocmd: c_int = 293; +pub const CMD_nohlsearch: c_int = 294; +pub const CMD_noreabbrev: c_int = 295; +pub const CMD_noremenu: c_int = 296; +pub const CMD_noswapfile: c_int = 297; +pub const CMD_normal: c_int = 298; +pub const CMD_number: c_int = 299; +pub const CMD_nunmap: c_int = 300; +pub const CMD_nunmenu: c_int = 301; +pub const CMD_oldfiles: c_int = 302; +pub const CMD_omap: c_int = 303; +pub const CMD_omapclear: c_int = 304; +pub const CMD_omenu: c_int = 305; +pub const CMD_only: c_int = 306; +pub const CMD_onoremap: c_int = 307; +pub const CMD_onoremenu: c_int = 308; +pub const CMD_options: c_int = 309; +pub const CMD_ounmap: c_int = 310; +pub const CMD_ounmenu: c_int = 311; +pub const CMD_ownsyntax: c_int = 312; +pub const CMD_print: c_int = 313; +pub const CMD_packadd: c_int = 314; +pub const CMD_packloadall: c_int = 315; +pub const CMD_pclose: c_int = 316; +pub const CMD_perl: c_int = 317; +pub const CMD_perldo: c_int = 318; +pub const CMD_perlfile: c_int = 319; +pub const CMD_pedit: c_int = 320; +pub const CMD_pop: c_int = 321; +pub const CMD_popup: c_int = 322; +pub const CMD_ppop: c_int = 323; +pub const CMD_preserve: c_int = 324; +pub const CMD_previous: c_int = 325; +pub const CMD_profile: c_int = 326; +pub const CMD_profdel: c_int = 327; +pub const CMD_psearch: c_int = 328; +pub const CMD_ptag: c_int = 329; +pub const CMD_ptNext: c_int = 330; +pub const CMD_ptfirst: c_int = 331; +pub const CMD_ptjump: c_int = 332; +pub const CMD_ptlast: c_int = 333; +pub const CMD_ptnext: c_int = 334; +pub const CMD_ptprevious: c_int = 335; +pub const CMD_ptrewind: c_int = 336; +pub const CMD_ptselect: c_int = 337; +pub const CMD_put: c_int = 338; +pub const CMD_pwd: c_int = 339; +pub const CMD_python: c_int = 340; +pub const CMD_pydo: c_int = 341; +pub const CMD_pyfile: c_int = 342; +pub const CMD_py3: c_int = 343; +pub const CMD_py3do: c_int = 344; +pub const CMD_python3: c_int = 345; +pub const CMD_py3file: c_int = 346; +pub const CMD_pyx: c_int = 347; +pub const CMD_pyxdo: c_int = 348; +pub const CMD_pythonx: c_int = 349; +pub const CMD_pyxfile: c_int = 350; +pub const CMD_quit: c_int = 351; +pub const CMD_quitall: c_int = 352; +pub const CMD_qall: c_int = 353; +pub const CMD_read: c_int = 354; +pub const CMD_recover: c_int = 355; +pub const CMD_redo: c_int = 356; +pub const CMD_redir: c_int = 357; +pub const CMD_redraw: c_int = 358; +pub const CMD_redrawstatus: c_int = 359; +pub const CMD_redrawtabline: c_int = 360; +pub const CMD_registers: c_int = 361; +pub const CMD_resize: c_int = 362; +pub const CMD_retab: c_int = 363; +pub const CMD_return: c_int = 364; +pub const CMD_rewind: c_int = 365; +pub const CMD_right: c_int = 366; +pub const CMD_rightbelow: c_int = 367; +pub const CMD_rshada: c_int = 368; +pub const CMD_runtime: c_int = 369; +pub const CMD_rundo: c_int = 370; +pub const CMD_ruby: c_int = 371; +pub const CMD_rubydo: c_int = 372; +pub const CMD_rubyfile: c_int = 373; +pub const CMD_rviminfo: c_int = 374; +pub const CMD_substitute: c_int = 375; +pub const CMD_sNext: c_int = 376; +pub const CMD_sargument: c_int = 377; +pub const CMD_sall: c_int = 378; +pub const CMD_sandbox: c_int = 379; +pub const CMD_saveas: c_int = 380; +pub const CMD_sbuffer: c_int = 381; +pub const CMD_sbNext: c_int = 382; +pub const CMD_sball: c_int = 383; +pub const CMD_sbfirst: c_int = 384; +pub const CMD_sblast: c_int = 385; +pub const CMD_sbmodified: c_int = 386; +pub const CMD_sbnext: c_int = 387; +pub const CMD_sbprevious: c_int = 388; +pub const CMD_sbrewind: c_int = 389; +pub const CMD_scriptnames: c_int = 390; +pub const CMD_scriptencoding: c_int = 391; +pub const CMD_set: c_int = 392; +pub const CMD_setfiletype: c_int = 393; +pub const CMD_setglobal: c_int = 394; +pub const CMD_setlocal: c_int = 395; +pub const CMD_sfind: c_int = 396; +pub const CMD_sfirst: c_int = 397; +pub const CMD_simalt: c_int = 398; +pub const CMD_sign: c_int = 399; +pub const CMD_silent: c_int = 400; +pub const CMD_sleep: c_int = 401; +pub const CMD_slast: c_int = 402; +pub const CMD_smagic: c_int = 403; +pub const CMD_smap: c_int = 404; +pub const CMD_smapclear: c_int = 405; +pub const CMD_smenu: c_int = 406; +pub const CMD_snext: c_int = 407; +pub const CMD_snomagic: c_int = 408; +pub const CMD_snoremap: c_int = 409; +pub const CMD_snoremenu: c_int = 410; +pub const CMD_source: c_int = 411; +pub const CMD_sort: c_int = 412; +pub const CMD_split: c_int = 413; +pub const CMD_spellgood: c_int = 414; +pub const CMD_spelldump: c_int = 415; +pub const CMD_spellinfo: c_int = 416; +pub const CMD_spellrepall: c_int = 417; +pub const CMD_spellrare: c_int = 418; +pub const CMD_spellundo: c_int = 419; +pub const CMD_spellwrong: c_int = 420; +pub const CMD_sprevious: c_int = 421; +pub const CMD_srewind: c_int = 422; +pub const CMD_stop: c_int = 423; +pub const CMD_stag: c_int = 424; +pub const CMD_startinsert: c_int = 425; +pub const CMD_startgreplace: c_int = 426; +pub const CMD_startreplace: c_int = 427; +pub const CMD_stopinsert: c_int = 428; +pub const CMD_stjump: c_int = 429; +pub const CMD_stselect: c_int = 430; +pub const CMD_sunhide: c_int = 431; +pub const CMD_sunmap: c_int = 432; +pub const CMD_sunmenu: c_int = 433; +pub const CMD_suspend: c_int = 434; +pub const CMD_sview: c_int = 435; +pub const CMD_swapname: c_int = 436; +pub const CMD_syntax: c_int = 437; +pub const CMD_syntime: c_int = 438; +pub const CMD_syncbind: c_int = 439; +pub const CMD_t: c_int = 440; +pub const CMD_tcd: c_int = 441; +pub const CMD_tchdir: c_int = 442; +pub const CMD_tNext: c_int = 443; +pub const CMD_tag: c_int = 444; +pub const CMD_tags: c_int = 445; +pub const CMD_tab: c_int = 446; +pub const CMD_tabclose: c_int = 447; +pub const CMD_tabdo: c_int = 448; +pub const CMD_tabedit: c_int = 449; +pub const CMD_tabfind: c_int = 450; +pub const CMD_tabfirst: c_int = 451; +pub const CMD_tabmove: c_int = 452; +pub const CMD_tablast: c_int = 453; +pub const CMD_tabnext: c_int = 454; +pub const CMD_tabnew: c_int = 455; +pub const CMD_tabonly: c_int = 456; +pub const CMD_tabprevious: c_int = 457; +pub const CMD_tabNext: c_int = 458; +pub const CMD_tabrewind: c_int = 459; +pub const CMD_tabs: c_int = 460; +pub const CMD_tcl: c_int = 461; +pub const CMD_tcldo: c_int = 462; +pub const CMD_tclfile: c_int = 463; +pub const CMD_terminal: c_int = 464; +pub const CMD_tfirst: c_int = 465; +pub const CMD_throw: c_int = 466; +pub const CMD_tjump: c_int = 467; +pub const CMD_tlast: c_int = 468; +pub const CMD_tlmenu: c_int = 469; +pub const CMD_tlnoremenu: c_int = 470; +pub const CMD_tlunmenu: c_int = 471; +pub const CMD_tmenu: c_int = 472; +pub const CMD_tmap: c_int = 473; +pub const CMD_tmapclear: c_int = 474; +pub const CMD_tnext: c_int = 475; +pub const CMD_tnoremap: c_int = 476; +pub const CMD_topleft: c_int = 477; +pub const CMD_tprevious: c_int = 478; +pub const CMD_trewind: c_int = 479; +pub const CMD_trust: c_int = 480; +pub const CMD_try: c_int = 481; +pub const CMD_tselect: c_int = 482; +pub const CMD_tunmenu: c_int = 483; +pub const CMD_tunmap: c_int = 484; +pub const CMD_undo: c_int = 485; +pub const CMD_undojoin: c_int = 486; +pub const CMD_undolist: c_int = 487; +pub const CMD_unabbreviate: c_int = 488; +pub const CMD_unhide: c_int = 489; +pub const CMD_unlet: c_int = 490; +pub const CMD_unlockvar: c_int = 491; +pub const CMD_unmap: c_int = 492; +pub const CMD_unmenu: c_int = 493; +pub const CMD_unsilent: c_int = 494; +pub const CMD_update: c_int = 495; +pub const CMD_vglobal: c_int = 496; +pub const CMD_version: c_int = 497; +pub const CMD_verbose: c_int = 498; +pub const CMD_vertical: c_int = 499; +pub const CMD_visual: c_int = 500; +pub const CMD_view: c_int = 501; +pub const CMD_vimgrep: c_int = 502; +pub const CMD_vimgrepadd: c_int = 503; +pub const CMD_viusage: c_int = 504; +pub const CMD_vmap: c_int = 505; +pub const CMD_vmapclear: c_int = 506; +pub const CMD_vmenu: c_int = 507; +pub const CMD_vnoremap: c_int = 508; +pub const CMD_vnew: c_int = 509; +pub const CMD_vnoremenu: c_int = 510; +pub const CMD_vsplit: c_int = 511; +pub const CMD_vunmap: c_int = 512; +pub const CMD_vunmenu: c_int = 513; +pub const CMD_write: c_int = 514; +pub const CMD_wNext: c_int = 515; +pub const CMD_wall: c_int = 516; +pub const CMD_while: c_int = 517; +pub const CMD_winsize: c_int = 518; +pub const CMD_wincmd: c_int = 519; +pub const CMD_windo: c_int = 520; +pub const CMD_winpos: c_int = 521; +pub const CMD_wnext: c_int = 522; +pub const CMD_wprevious: c_int = 523; +pub const CMD_wq: c_int = 524; +pub const CMD_wqall: c_int = 525; +pub const CMD_wshada: c_int = 526; +pub const CMD_wundo: c_int = 527; +pub const CMD_wviminfo: c_int = 528; +pub const CMD_xit: c_int = 529; +pub const CMD_xall: c_int = 530; +pub const CMD_xmap: c_int = 531; +pub const CMD_xmapclear: c_int = 532; +pub const CMD_xmenu: c_int = 533; +pub const CMD_xnoremap: c_int = 534; +pub const CMD_xnoremenu: c_int = 535; +pub const CMD_xunmap: c_int = 536; +pub const CMD_xunmenu: c_int = 537; +pub const CMD_yank: c_int = 538; +pub const CMD_z: c_int = 539; +pub const CMD_bang: c_int = 540; +pub const CMD_pound: c_int = 541; +pub const CMD_and: c_int = 542; +pub const CMD_lshift: c_int = 543; +pub const CMD_equal: c_int = 544; +pub const CMD_rshift: c_int = 545; +pub const CMD_at: c_int = 546; +pub const CMD_tilde: c_int = 547; +pub const CMD_Next: c_int = 548; +pub const CMD_SIZE: c_int = 549; +pub const CMD_USER: c_int = -1; +pub const CMD_USER_BUF: c_int = -2; +pub const enum_CMD_index = c_int; +pub const cmdidx_T = enum_CMD_index; +pub const ADDR_LINES: c_int = 0; +pub const ADDR_WINDOWS: c_int = 1; +pub const ADDR_ARGUMENTS: c_int = 2; +pub const ADDR_LOADED_BUFFERS: c_int = 3; +pub const ADDR_BUFFERS: c_int = 4; +pub const ADDR_TABS: c_int = 5; +pub const ADDR_TABS_RELATIVE: c_int = 6; +pub const ADDR_QUICKFIX_VALID: c_int = 7; +pub const ADDR_QUICKFIX: c_int = 8; +pub const ADDR_UNSIGNED: c_int = 9; +pub const ADDR_OTHER: c_int = 10; +pub const ADDR_NONE: c_int = 11; +pub const cmd_addr_T = c_uint; +pub const LineGetter = ?*const fn (c_int, ?*anyopaque, c_int, bool) callconv(.C) [*c]u8; +pub const struct_exarg = extern struct { + arg: [*c]u8, + args: [*c][*c]u8, + arglens: [*c]usize, + argc: usize, + nextcmd: [*c]u8, + cmd: [*c]u8, + cmdlinep: [*c][*c]u8, + cmdline_tofree: [*c]u8, + cmdidx: cmdidx_T, + argt: u32, + skip: c_int, + forceit: c_int, + addr_count: c_int, + line1: linenr_T, + line2: linenr_T, + addr_type: cmd_addr_T, + flags: c_int, + do_ecmd_cmd: [*c]u8, + do_ecmd_lnum: linenr_T, + append: c_int, + usefilter: c_int, + amount: c_int, + regname: c_int, + force_bin: c_int, + read_edit: c_int, + mkdir_p: c_int, + force_ff: c_int, + force_enc: c_int, + bad_char: c_int, + useridx: c_int, + errmsg: [*c]u8, + getline: LineGetter, + cookie: ?*anyopaque, + cstack: [*c]cstack_T, +}; +pub const exarg_T = struct_exarg; +pub const ex_func_T = ?*const fn ([*c]exarg_T) callconv(.C) void; +pub const ex_preview_func_T = ?*const fn ([*c]exarg_T, c_long, handle_T) callconv(.C) c_int; +pub const CALLABLE_NONE: c_int = 0; +pub const CALLABLE_EX: c_int = 1; +pub const CALLABLE_CB: c_int = 2; +pub const AucmdExecutableType = c_uint; +const union_unnamed_110 = extern union { + cmd: [*c]u8, + cb: Callback, +}; +pub const struct_aucmd_executable_t = extern struct { + type: AucmdExecutableType, + callable: union_unnamed_110, +}; +pub const AucmdExecutable = struct_aucmd_executable_t; +pub const struct_cmdname = extern struct { + cmd_name: [*c]u8, + cmd_func: ex_func_T, + cmd_preview_func: ex_preview_func_T, + cmd_argt: u32, + cmd_addr_type: cmd_addr_T, +}; +pub const CommandDefinition = struct_cmdname; +pub const eslist_T = struct_eslist_elem; +pub const struct_eslist_elem = extern struct { + saved_emsg_silent: c_int, + next: [*c]eslist_T, +}; +pub const CSTACK_LEN: c_int = 50; +const enum_unnamed_111 = c_uint; +const union_unnamed_112 = extern union { + csp_rv: [50]?*anyopaque, + csp_ex: [50]?*anyopaque, +}; +pub const cstack_T = extern struct { + cs_flags: [50]c_int, + cs_pending: [50]u8, + cs_pend: union_unnamed_112, + cs_forinfo: [50]?*anyopaque, + cs_line: [50]c_int, + cs_idx: c_int, + cs_looplevel: c_int, + cs_trylevel: c_int, + cs_emsg_silent_list: [*c]eslist_T, + cs_lflags: c_int, +}; +pub const CSL_HAD_LOOP: c_int = 1; +pub const CSL_HAD_ENDLOOP: c_int = 2; +pub const CSL_HAD_CONT: c_int = 4; +pub const CSL_HAD_FINA: c_int = 8; +const enum_unnamed_113 = c_uint; +pub const CMOD_SANDBOX: c_int = 1; +pub const CMOD_SILENT: c_int = 2; +pub const CMOD_ERRSILENT: c_int = 4; +pub const CMOD_UNSILENT: c_int = 8; +pub const CMOD_NOAUTOCMD: c_int = 16; +pub const CMOD_HIDE: c_int = 32; +pub const CMOD_BROWSE: c_int = 64; +pub const CMOD_CONFIRM: c_int = 128; +pub const CMOD_KEEPALT: c_int = 256; +pub const CMOD_KEEPMARKS: c_int = 512; +pub const CMOD_KEEPJUMPS: c_int = 1024; +pub const CMOD_LOCKMARKS: c_int = 2048; +pub const CMOD_KEEPPATTERNS: c_int = 4096; +pub const CMOD_NOSWAPFILE: c_int = 8192; +const enum_unnamed_114 = c_uint; +pub const cmdmod_T = extern struct { + cmod_flags: c_int, + cmod_split: c_int, + cmod_tab: c_int, + cmod_filter_pat: [*c]u8, + cmod_filter_regmatch: regmatch_T, + cmod_filter_force: bool, + cmod_verbose: c_int, + cmod_save_ei: [*c]u8, + cmod_did_sandbox: c_int, + cmod_verbose_save: c_long, + cmod_save_msg_silent: c_int, + cmod_save_msg_scroll: c_int, + cmod_did_esilent: c_int, +}; +const struct_unnamed_115 = extern struct { + file: bool, + bar: bool, +}; +pub const CmdParseInfo = extern struct { + cmdmod: cmdmod_T, + magic: struct_unnamed_115, +}; +pub const SubReplacementString = extern struct { + sub: [*c]u8, + timestamp: Timestamp, + additional_elements: [*c]list_T, +}; +pub extern fn do_ascii(eap: [*c]const exarg_T) void; +pub extern fn ex_align(eap: [*c]exarg_T) void; +pub extern fn ex_sort(eap: [*c]exarg_T) void; +pub extern fn do_move(line1: linenr_T, line2: linenr_T, dest: linenr_T) c_int; +pub extern fn ex_copy(line1: linenr_T, line2: linenr_T, n: linenr_T) void; +pub extern fn do_bang(addr_count: c_int, eap: [*c]exarg_T, forceit: bool, do_in: bool, do_out: bool) void; +pub extern fn do_shell(cmd: [*c]u8, flags: c_int) void; +pub extern fn make_filter_cmd(cmd: [*c]u8, itmp: [*c]u8, otmp: [*c]u8) [*c]u8; +pub extern fn append_redir(buf: [*c]u8, buflen: usize, opt: [*c]const u8, fname: [*c]const u8) void; +pub extern fn print_line_no_prefix(lnum: linenr_T, use_number: c_int, list: c_int) void; +pub extern fn print_line(lnum: linenr_T, use_number: c_int, list: c_int) void; +pub extern fn rename_buffer(new_fname: [*c]u8) c_int; +pub extern fn ex_file(eap: [*c]exarg_T) void; +pub extern fn ex_update(eap: [*c]exarg_T) void; +pub extern fn ex_write(eap: [*c]exarg_T) void; +pub extern fn do_write(eap: [*c]exarg_T) c_int; +pub extern fn check_overwrite(eap: [*c]exarg_T, buf: [*c]buf_T, fname: [*c]u8, ffname: [*c]u8, other: c_int) c_int; +pub extern fn ex_wnext(eap: [*c]exarg_T) void; +pub extern fn do_wqall(eap: [*c]exarg_T) void; +pub extern fn not_writing() bool; +pub extern fn getfile(fnum: c_int, ffname_arg: [*c]u8, sfname_arg: [*c]u8, setpm: c_int, lnum: linenr_T, forceit: c_int) c_int; +pub extern fn do_ecmd(fnum: c_int, ffname: [*c]u8, sfname: [*c]u8, eap: [*c]exarg_T, newlnum: linenr_T, flags: c_int, oldwin: [*c]win_T) c_int; +pub extern fn ex_append(eap: [*c]exarg_T) void; +pub extern fn ex_change(eap: [*c]exarg_T) void; +pub extern fn ex_z(eap: [*c]exarg_T) void; +pub extern fn check_secure() bool; +pub extern fn sub_get_replacement(ret_sub: [*c]SubReplacementString) void; +pub extern fn sub_set_replacement(sub: SubReplacementString) void; +pub extern fn do_sub_msg(count_only: bool) bool; +pub extern fn ex_global(eap: [*c]exarg_T) void; +pub extern fn global_exe(cmd: [*c]u8) void; +pub extern fn prepare_tagpreview(undo_sync: bool) bool; +pub extern fn ex_substitute(eap: [*c]exarg_T) void; +pub extern fn ex_substitute_preview(eap: [*c]exarg_T, cmdpreview_ns: c_long, cmdpreview_bufnr: handle_T) c_int; +pub extern fn skip_vimgrep_pat(p: [*c]u8, s: [*c][*c]u8, flags: [*c]c_int) [*c]u8; +pub extern fn ex_oldfiles(eap: [*c]exarg_T) void; +pub extern fn ex_trust(eap: [*c]exarg_T) void; +pub extern fn nvim_parse_cmd(str: String, opts: Dictionary, err: [*c]Error) Dictionary; +pub extern fn nvim_cmd(channel_id: u64, cmd: [*c]KeyDict_cmd, opts: [*c]KeyDict_cmd_opts, err: [*c]Error) String; +pub extern fn nvim_create_user_command(channel_id: u64, name: String, command: Object, opts: [*c]KeyDict_user_command, err: [*c]Error) void; +pub extern fn nvim_del_user_command(name: String, err: [*c]Error) void; +pub extern fn nvim_buf_create_user_command(channel_id: u64, buffer: Buffer, name: String, command: Object, opts: [*c]KeyDict_user_command, err: [*c]Error) void; +pub extern fn nvim_buf_del_user_command(buffer: Buffer, name: String, err: [*c]Error) void; +pub extern fn create_user_command(channel_id: u64, name: String, command: Object, opts: [*c]KeyDict_user_command, flags: c_int, err: [*c]Error) void; +pub extern fn nvim_get_commands(opts: [*c]KeyDict_get_commands, err: [*c]Error) Dictionary; +pub extern fn nvim_buf_get_commands(buffer: Buffer, opts: [*c]KeyDict_get_commands, err: [*c]Error) Dictionary; +pub extern fn nvim_exec(channel_id: u64, src: String, output: Boolean, err: [*c]Error) String; +pub extern fn nvim_command_output(channel_id: u64, command: String, err: [*c]Error) String; +pub extern fn nvim_execute_lua(code: String, args: Array, err: [*c]Error) Object; +pub extern fn nvim_buf_get_number(buffer: Buffer, err: [*c]Error) Integer; +pub extern fn nvim_buf_clear_highlight(buffer: Buffer, ns_id: Integer, line_start: Integer, line_end: Integer, err: [*c]Error) void; +pub extern fn nvim_buf_set_virtual_text(buffer: Buffer, src_id: Integer, line: Integer, chunks: Array, opts: Dictionary, err: [*c]Error) Integer; +pub extern fn nvim_get_hl_by_id(hl_id: Integer, rgb: Boolean, arena: [*c]Arena, err: [*c]Error) Dictionary; +pub extern fn nvim_get_hl_by_name(name: String, rgb: Boolean, arena: [*c]Arena, err: [*c]Error) Dictionary; +pub extern fn buffer_insert(buffer: Buffer, lnum: Integer, lines: Array, err: [*c]Error) void; +pub extern fn buffer_get_line(buffer: Buffer, index: Integer, err: [*c]Error) String; +pub extern fn buffer_set_line(buffer: Buffer, index: Integer, line: String, err: [*c]Error) void; +pub extern fn buffer_del_line(buffer: Buffer, index: Integer, err: [*c]Error) void; +pub extern fn buffer_get_line_slice(buffer: Buffer, start: Integer, end: Integer, include_start: Boolean, include_end: Boolean, err: [*c]Error) Array; +pub extern fn buffer_set_line_slice(buffer: Buffer, start: Integer, end: Integer, include_start: Boolean, include_end: Boolean, replacement: Array, err: [*c]Error) void; +pub extern fn buffer_set_var(buffer: Buffer, name: String, value: Object, err: [*c]Error) Object; +pub extern fn buffer_del_var(buffer: Buffer, name: String, err: [*c]Error) Object; +pub extern fn window_set_var(window: Window, name: String, value: Object, err: [*c]Error) Object; +pub extern fn window_del_var(window: Window, name: String, err: [*c]Error) Object; +pub extern fn tabpage_set_var(tabpage: Tabpage, name: String, value: Object, err: [*c]Error) Object; +pub extern fn tabpage_del_var(tabpage: Tabpage, name: String, err: [*c]Error) Object; +pub extern fn vim_set_var(name: String, value: Object, err: [*c]Error) Object; +pub extern fn vim_del_var(name: String, err: [*c]Error) Object; +pub extern fn nvim_get_option_info(name: String, err: [*c]Error) Dictionary; +pub extern var namespace_ids: Map_String_handle_T; +pub extern var next_namespace_id: handle_T; +pub extern fn api_extmark_free_all_mem() void; +pub extern fn nvim_create_namespace(name: String) Integer; +pub extern fn nvim_get_namespaces() Dictionary; +pub extern fn describe_ns(ns_id: NS) [*c]const u8; +pub extern fn ns_initialized(ns: u32) bool; +pub extern fn nvim_buf_get_extmark_by_id(buffer: Buffer, ns_id: Integer, id: Integer, opts: Dictionary, err: [*c]Error) Array; +pub extern fn nvim_buf_get_extmarks(buffer: Buffer, ns_id: Integer, start: Object, end: Object, opts: Dictionary, err: [*c]Error) Array; +pub extern fn nvim_buf_set_extmark(buffer: Buffer, ns_id: Integer, line: Integer, col: Integer, opts: [*c]KeyDict_set_extmark, err: [*c]Error) Integer; +pub extern fn nvim_buf_del_extmark(buffer: Buffer, ns_id: Integer, id: Integer, err: [*c]Error) Boolean; +pub extern fn src2ns(src_id: [*c]Integer) u32; +pub extern fn nvim_buf_add_highlight(buffer: Buffer, ns_id: Integer, hl_group: String, line: Integer, col_start: Integer, col_end: Integer, err: [*c]Error) Integer; +pub extern fn nvim_buf_clear_namespace(buffer: Buffer, ns_id: Integer, line_start: Integer, line_end: Integer, err: [*c]Error) void; +pub extern fn nvim_set_decoration_provider(ns_id: Integer, opts: [*c]KeyDict_set_decoration_provider, err: [*c]Error) void; +pub extern fn parse_virt_text(chunks: Array, err: [*c]Error, width: [*c]c_int) VirtText; +pub extern fn nvim_get_option_value(name: String, opts: [*c]KeyDict_option, err: [*c]Error) Object; +pub extern fn nvim_set_option_value(channel_id: u64, name: String, value: Object, opts: [*c]KeyDict_option, err: [*c]Error) void; +pub extern fn nvim_get_all_options_info(err: [*c]Error) Dictionary; +pub extern fn nvim_get_option_info2(name: String, opts: [*c]KeyDict_option, err: [*c]Error) Dictionary; +pub extern fn nvim_set_option(channel_id: u64, name: String, value: Object, err: [*c]Error) void; +pub extern fn nvim_get_option(name: String, arena: [*c]Arena, err: [*c]Error) Object; +pub extern fn nvim_buf_get_option(buffer: Buffer, name: String, arena: [*c]Arena, err: [*c]Error) Object; +pub extern fn nvim_buf_set_option(channel_id: u64, buffer: Buffer, name: String, value: Object, err: [*c]Error) void; +pub extern fn nvim_win_get_option(window: Window, name: String, arena: [*c]Arena, err: [*c]Error) Object; +pub extern fn nvim_win_set_option(channel_id: u64, window: Window, name: String, value: Object, err: [*c]Error) void; +pub extern fn set_option_to(channel_id: u64, to: ?*anyopaque, @"type": c_int, name: String, value: Object, err: [*c]Error) void; +pub extern fn nvim_tabpage_list_wins(tabpage: Tabpage, err: [*c]Error) Array; +pub extern fn nvim_tabpage_get_var(tabpage: Tabpage, name: String, err: [*c]Error) Object; +pub extern fn nvim_tabpage_set_var(tabpage: Tabpage, name: String, value: Object, err: [*c]Error) void; +pub extern fn nvim_tabpage_del_var(tabpage: Tabpage, name: String, err: [*c]Error) void; +pub extern fn nvim_tabpage_get_win(tabpage: Tabpage, err: [*c]Error) Window; +pub extern fn nvim_tabpage_get_number(tabpage: Tabpage, err: [*c]Error) Integer; +pub extern fn nvim_tabpage_is_valid(tabpage: Tabpage) Boolean; +pub const argv_callback = ?*const fn ([*c]?*anyopaque) callconv(.C) void; +pub const struct_message = extern struct { + handler: argv_callback, + argv: [10]?*anyopaque, +}; +pub const Event = struct_message; +pub const event_scheduler = ?*const fn (Event, ?*anyopaque) callconv(.C) void; // ./_nvim/src/nvim/event/defs.h:30:21: warning: TODO unable to translate variadic function, demoted to extern +pub extern fn event_create(cb: argv_callback, argc: c_int, ...) Event; +pub const struct_multiqueue = opaque {}; +pub const MultiQueue = struct_multiqueue; +pub const PutCallback = ?*const fn (?*MultiQueue, ?*anyopaque) callconv(.C) void; +pub extern fn multiqueue_new_parent(put_cb: PutCallback, data: ?*anyopaque) ?*MultiQueue; +pub extern fn multiqueue_new_child(parent: ?*MultiQueue) ?*MultiQueue; +pub extern fn multiqueue_free(self: ?*MultiQueue) void; +pub extern fn multiqueue_get(self: ?*MultiQueue) Event; +pub extern fn multiqueue_put_event(self: ?*MultiQueue, event: Event) void; +pub extern fn multiqueue_process_events(self: ?*MultiQueue) void; +pub extern fn multiqueue_purge_events(self: ?*MultiQueue) void; +pub extern fn multiqueue_empty(self: ?*MultiQueue) bool; +pub extern fn multiqueue_replace_parent(self: ?*MultiQueue, new_parent: ?*MultiQueue) void; +pub extern fn multiqueue_size(self: ?*MultiQueue) usize; +pub extern fn event_create_oneshot(ev: Event, num: c_int) Event; +pub inline fn ascii_iswhite(arg_c: c_int) bool { + var c = arg_c; + return (c == @as(c_int, ' ')) or (c == @as(c_int, '\t')); +} +pub inline fn ascii_iswhite_or_nul(arg_c: c_int) bool { + var c = arg_c; + return (@as(c_int, @boolToInt(ascii_iswhite(c))) != 0) or (c == @as(c_int, '\x00')); +} +pub inline fn ascii_isdigit(arg_c: c_int) bool { + var c = arg_c; + return (c >= @as(c_int, '0')) and (c <= @as(c_int, '9')); +} +pub inline fn ascii_isxdigit(arg_c: c_int) bool { + var c = arg_c; + return (((c >= @as(c_int, '0')) and (c <= @as(c_int, '9'))) or ((c >= @as(c_int, 'a')) and (c <= @as(c_int, 'f')))) or ((c >= @as(c_int, 'A')) and (c <= @as(c_int, 'F'))); +} +pub inline fn ascii_isident(arg_c: c_int) bool { + var c = arg_c; + return ((((@bitCast(c_uint, c) >= @bitCast(c_uint, @as(c_int, 'A'))) and (@bitCast(c_uint, c) <= @bitCast(c_uint, @as(c_int, 'Z')))) or ((@bitCast(c_uint, c) >= @bitCast(c_uint, @as(c_int, 'a'))) and (@bitCast(c_uint, c) <= @bitCast(c_uint, @as(c_int, 'z'))))) or (@as(c_int, @boolToInt(ascii_isdigit(c))) != 0)) or (c == @as(c_int, '_')); +} +pub inline fn ascii_isbdigit(arg_c: c_int) bool { + var c = arg_c; + return (c == @as(c_int, '0')) or (c == @as(c_int, '1')); +} +pub inline fn ascii_isspace(arg_c: c_int) bool { + var c = arg_c; + return ((c >= @as(c_int, 9)) and (c <= @as(c_int, 13))) or (c == @as(c_int, ' ')); +} +pub fn ascii_isodigit(arg_c: c_int) callconv(.C) bool { + var c = arg_c; + return (c >= @as(c_int, '0')) and (c <= @as(c_int, '7')); +} +pub const WatcherPtr = ?*anyopaque; +pub const struct___kl1_WatcherPtr = extern struct { + data: WatcherPtr, + next: [*c]struct___kl1_WatcherPtr, +}; +pub const kl1_WatcherPtr = struct___kl1_WatcherPtr; +pub const kmp_WatcherPtr_t = extern struct { + cnt: usize, + n: usize, + max: usize, + buf: [*c][*c]kl1_WatcherPtr, +}; +pub fn kmp_init_WatcherPtr() callconv(.C) [*c]kmp_WatcherPtr_t { + return @ptrCast([*c]kmp_WatcherPtr_t, @alignCast(@import("std").meta.alignment([*c]kmp_WatcherPtr_t), xcalloc(@bitCast(usize, @as(c_long, @as(c_int, 1))), @sizeOf(kmp_WatcherPtr_t)))); +} +pub fn kmp_destroy_WatcherPtr(arg_mp: [*c]kmp_WatcherPtr_t) callconv(.C) void { + var mp = arg_mp; + var k: usize = undefined; + { + k = 0; + while (k < mp.*.n) : (k +%= 1) { + while (true) { + var ptr_: [*c]?*anyopaque = @ptrCast([*c]?*anyopaque, @alignCast(@import("std").meta.alignment([*c]?*anyopaque), &mp.*.buf[k])); + xfree(ptr_.*); + ptr_.* = @intToPtr(?*anyopaque, @as(c_int, 0)); + _ = ptr_.*; + if (!false) break; + } + } + } + while (true) { + var ptr_: [*c]?*anyopaque = @ptrCast([*c]?*anyopaque, @alignCast(@import("std").meta.alignment([*c]?*anyopaque), &mp.*.buf)); + xfree(ptr_.*); + ptr_.* = @intToPtr(?*anyopaque, @as(c_int, 0)); + _ = ptr_.*; + if (!false) break; + } + while (true) { + var ptr_: [*c]?*anyopaque = @ptrCast([*c]?*anyopaque, @alignCast(@import("std").meta.alignment([*c]?*anyopaque), &mp)); + xfree(ptr_.*); + ptr_.* = @intToPtr(?*anyopaque, @as(c_int, 0)); + _ = ptr_.*; + if (!false) break; + } +} +pub fn kmp_alloc_WatcherPtr(arg_mp: [*c]kmp_WatcherPtr_t) callconv(.C) [*c]kl1_WatcherPtr { + var mp = arg_mp; + mp.*.cnt +%= 1; + if (mp.*.n == @bitCast(usize, @as(c_long, @as(c_int, 0)))) { + return @ptrCast([*c]kl1_WatcherPtr, @alignCast(@import("std").meta.alignment([*c]kl1_WatcherPtr), xcalloc(@bitCast(usize, @as(c_long, @as(c_int, 1))), @sizeOf(kl1_WatcherPtr)))); + } + return mp.*.buf[blk: { + const ref = &mp.*.n; + ref.* -%= 1; + break :blk ref.*; + }]; +} +pub fn kmp_free_WatcherPtr(arg_mp: [*c]kmp_WatcherPtr_t, arg_p: [*c]kl1_WatcherPtr) callconv(.C) void { + var mp = arg_mp; + var p = arg_p; + mp.*.cnt -%= 1; + if (mp.*.n == mp.*.max) { + mp.*.max = if (mp.*.max != 0) mp.*.max << @intCast(@import("std").math.Log2Int(usize), 1) else @bitCast(usize, @as(c_long, @as(c_int, 16))); + mp.*.buf = @ptrCast([*c][*c]kl1_WatcherPtr, @alignCast(@import("std").meta.alignment([*c][*c]kl1_WatcherPtr), xrealloc(@ptrCast(?*anyopaque, mp.*.buf), @sizeOf([*c]kl1_WatcherPtr) *% mp.*.max))); + } + mp.*.buf[blk: { + const ref = &mp.*.n; + const tmp = ref.*; + ref.* +%= 1; + break :blk tmp; + }] = p; +} +pub const kl_WatcherPtr_t = extern struct { + head: [*c]kl1_WatcherPtr, + tail: [*c]kl1_WatcherPtr, + mp: [*c]kmp_WatcherPtr_t, + size: usize, +}; +pub fn kl_init_WatcherPtr() callconv(.C) [*c]kl_WatcherPtr_t { + var kl: [*c]kl_WatcherPtr_t = @ptrCast([*c]kl_WatcherPtr_t, @alignCast(@import("std").meta.alignment([*c]kl_WatcherPtr_t), xcalloc(@bitCast(usize, @as(c_long, @as(c_int, 1))), @sizeOf(kl_WatcherPtr_t)))); + kl.*.mp = kmp_init_WatcherPtr(); + kl.*.head = blk: { + const tmp = kmp_alloc_WatcherPtr(kl.*.mp); + kl.*.tail = tmp; + break :blk tmp; + }; + kl.*.head.*.next = null; + return kl; +} +pub fn kl_destroy_WatcherPtr(arg_kl: [*c]kl_WatcherPtr_t) callconv(.C) void { + var kl = arg_kl; + var p: [*c]kl1_WatcherPtr = undefined; + { + p = kl.*.head; + while (p != kl.*.tail) : (p = p.*.next) { + kmp_free_WatcherPtr(kl.*.mp, p); + } + } + kmp_free_WatcherPtr(kl.*.mp, p); + kmp_destroy_WatcherPtr(kl.*.mp); + while (true) { + var ptr_: [*c]?*anyopaque = @ptrCast([*c]?*anyopaque, @alignCast(@import("std").meta.alignment([*c]?*anyopaque), &kl)); + xfree(ptr_.*); + ptr_.* = @intToPtr(?*anyopaque, @as(c_int, 0)); + _ = ptr_.*; + if (!false) break; + } +} +pub fn kl_push_WatcherPtr(arg_kl: [*c]kl_WatcherPtr_t, arg_d: WatcherPtr) callconv(.C) void { + var kl = arg_kl; + var d = arg_d; + var q: [*c]kl1_WatcherPtr = undefined; + var p: [*c]kl1_WatcherPtr = kmp_alloc_WatcherPtr(kl.*.mp); + q = kl.*.tail; + p.*.next = null; + kl.*.tail.*.next = p; + kl.*.tail = p; + kl.*.size +%= 1; + q.*.data = d; +} +pub fn kl_shift_at_WatcherPtr(arg_kl: [*c]kl_WatcherPtr_t, arg_n: [*c][*c]kl1_WatcherPtr) callconv(.C) WatcherPtr { + var kl = arg_kl; + var n = arg_n; + _ = blk: { + _ = @sizeOf(c_int); + break :blk blk_1: { + break :blk_1 if (n.*.*.next != null) {} else { + __assert_fail("(*n)->next", "_nvim/src/nvim/event/loop.h", @bitCast(c_uint, @as(c_int, 14)), "WatcherPtr kl_shift_at_WatcherPtr(kl_WatcherPtr_t *, kl1_WatcherPtr **)"); + }; + }; + }; + var p: [*c]kl1_WatcherPtr = undefined; + kl.*.size -%= 1; + p = n.*; + n.* = n.*.*.next; + if (p == kl.*.head) { + kl.*.head = n.*; + } + var d: WatcherPtr = p.*.data; + kmp_free_WatcherPtr(kl.*.mp, p); + return d; +} +pub const struct_loop = extern struct { + uv: uv_loop_t, + events: ?*MultiQueue, + thread_events: ?*MultiQueue, + fast_events: ?*MultiQueue, + children: [*c]kl_WatcherPtr_t, + children_watcher: uv_signal_t, + children_kill_timer: uv_timer_t, + poll_timer: uv_timer_t, + exit_delay_timer: uv_timer_t, + @"async": uv_async_t, + mutex: uv_mutex_t, + recursive: c_int, +}; +pub const Loop = struct_loop; +pub extern fn loop_init(loop: [*c]Loop, data: ?*anyopaque) void; +pub extern fn loop_uv_run(loop: [*c]Loop, ms: i64, once: bool) bool; +pub extern fn loop_poll_events(loop: [*c]Loop, ms: i64) bool; +pub extern fn loop_schedule_fast(loop: [*c]Loop, event: Event) void; +pub extern fn loop_schedule_deferred(loop: [*c]Loop, event: Event) void; +pub extern fn loop_on_put(queue: ?*MultiQueue, data: ?*anyopaque) void; +pub extern fn loop_close(loop: [*c]Loop, wait: bool) bool; +pub extern fn loop_purge(loop: [*c]Loop) void; +pub extern fn loop_size(loop: [*c]Loop) usize; +pub const CSF_TRUE: c_int = 1; +pub const CSF_ACTIVE: c_int = 2; +pub const CSF_ELSE: c_int = 4; +pub const CSF_WHILE: c_int = 8; +pub const CSF_FOR: c_int = 16; +pub const CSF_TRY: c_int = 256; +pub const CSF_FINALLY: c_int = 512; +pub const CSF_THROWN: c_int = 2048; +pub const CSF_CAUGHT: c_int = 4096; +pub const CSF_FINISHED: c_int = 8192; +pub const CSF_SILENT: c_int = 16384; +const enum_unnamed_116 = c_uint; +pub const CSTP_NONE: c_int = 0; +pub const CSTP_ERROR: c_int = 1; +pub const CSTP_INTERRUPT: c_int = 2; +pub const CSTP_THROW: c_int = 4; +pub const CSTP_BREAK: c_int = 8; +pub const CSTP_CONTINUE: c_int = 16; +pub const CSTP_RETURN: c_int = 24; +pub const CSTP_FINISH: c_int = 32; +const enum_unnamed_117 = c_uint; +pub const msglist_T = struct_msglist; +pub const struct_msglist = extern struct { + msg: [*c]u8, + throw_msg: [*c]u8, + sfile: [*c]u8, + slnum: linenr_T, + next: [*c]msglist_T, +}; +pub const ET_USER: c_int = 0; +pub const ET_ERROR: c_int = 1; +pub const ET_INTERRUPT: c_int = 2; +pub const except_type_T = c_uint; +pub const except_T = struct_vim_exception; +pub const struct_vim_exception = extern struct { + type: except_type_T, + value: [*c]u8, + messages: [*c]msglist_T, + throw_name: [*c]u8, + throw_lnum: linenr_T, + caught: [*c]except_T, +}; +pub const struct_cleanup_stuff = extern struct { + pending: c_int, + exception: [*c]except_T, +}; +pub const cleanup_T = struct_cleanup_stuff; +pub extern const utf8len_tab_zero: [256]u8; +pub extern const utf8len_tab: [256]u8; +pub extern fn enc_canon_props(name: [*c]const u8) c_int; +pub extern fn bomb_size() c_int; +pub extern fn remove_bom(s: [*c]u8) void; +pub extern fn mb_get_class(p: [*c]const u8) c_int; +pub extern fn mb_get_class_tab(p: [*c]const u8, chartab: [*c]const u64) c_int; +pub extern fn utf_char2cells(c: c_int) c_int; +pub extern fn utf_ptr2cells(p: [*c]const u8) c_int; +pub extern fn utf_ptr2cells_len(p: [*c]const u8, size: c_int) c_int; +pub extern fn mb_string2cells(str: [*c]const u8) usize; +pub extern fn mb_string2cells_len(str: [*c]const u8, size: usize) usize; +pub extern fn utf_ptr2char(p_in: [*c]const u8) c_int; +pub extern fn mb_ptr2char_adv(pp: [*c][*c]const u8) c_int; +pub extern fn mb_cptr2char_adv(pp: [*c][*c]const u8) c_int; +pub extern fn utf_composinglike(p1: [*c]const u8, p2: [*c]const u8) bool; +pub extern fn utfc_ptr2char(p: [*c]const u8, pcc: [*c]c_int) c_int; +pub extern fn utfc_ptr2char_len(p: [*c]const u8, pcc: [*c]c_int, maxlen: c_int) c_int; +pub extern fn utf_ptr2len(p_in: [*c]const u8) c_int; +pub extern fn utf_byte2len(b: c_int) c_int; +pub extern fn utf_ptr2len_len(p: [*c]const u8, size: c_int) c_int; +pub extern fn utfc_ptr2len(p: [*c]const u8) c_int; +pub extern fn utfc_ptr2len_len(p: [*c]const u8, size: c_int) c_int; +pub extern fn utf_char2len(c: c_int) c_int; +pub extern fn utf_char2bytes(c: c_int, buf: [*c]u8) c_int; +pub extern fn utf_iscomposing(c: c_int) bool; +pub extern fn utf_printable(c: c_int) bool; +pub extern fn utf_class(c: c_int) c_int; +pub extern fn utf_class_tab(c: c_int, chartab: [*c]const u64) c_int; +pub extern fn utf_ambiguous_width(c: c_int) bool; +pub extern fn utf_fold(a: c_int) c_int; +pub extern fn mb_toupper(a: c_int) c_int; +pub extern fn mb_islower(a: c_int) bool; +pub extern fn mb_tolower(a: c_int) c_int; +pub extern fn mb_isupper(a: c_int) bool; +pub extern fn mb_isalpha(a: c_int) bool; +pub extern fn mb_utflen(s: [*c]const u8, len: usize, codepoints: [*c]usize, codeunits: [*c]usize) void; +pub extern fn mb_utf_index_to_bytes(s: [*c]const u8, len: usize, index: usize, use_utf16_units: bool) isize; +pub extern fn mb_strnicmp(s1: [*c]const u8, s2: [*c]const u8, nn: usize) c_int; +pub extern fn mb_stricmp(s1: [*c]const u8, s2: [*c]const u8) c_int; +pub extern fn show_utf8() void; +pub extern fn utf_head_off(base_in: [*c]const u8, p_in: [*c]const u8) c_int; +pub extern fn utf_eat_space(cc: c_int) bool; +pub extern fn utf_allow_break_before(cc: c_int) bool; +pub extern fn utf_allow_break_after(cc: c_int) bool; +pub extern fn utf_allow_break(cc: c_int, ncc: c_int) bool; +pub extern fn mb_copy_char(fp: [*c][*c]const u8, tp: [*c][*c]u8) void; +pub extern fn mb_off_next(base: [*c]const u8, p_in: [*c]const u8) c_int; +pub extern fn utf_cp_tail_off(base: [*c]const u8, p_in: [*c]const u8) c_int; +pub extern fn utf_cp_head_off(base: [*c]const u8, p: [*c]const u8) c_int; +pub extern fn utf_find_illegal() void; +pub extern fn utf_valid_string(s: [*c]const u8, end: [*c]const u8) bool; +pub extern fn mb_adjust_cursor() void; +pub extern fn mb_check_adjust_col(win_: ?*anyopaque) void; +pub extern fn mb_prevptr(line: [*c]u8, p: [*c]u8) [*c]u8; +pub extern fn mb_charlen(str: [*c]const u8) c_int; +pub extern fn mb_charlen_len(str: [*c]const u8, len: c_int) c_int; +pub extern fn mb_unescape(pp: [*c][*c]const u8) [*c]const u8; +pub extern fn enc_skip(p: [*c]u8) [*c]u8; +pub extern fn enc_canonize(enc: [*c]u8) [*c]u8; +pub extern fn enc_locale() [*c]u8; +pub extern fn my_iconv_open(to: [*c]u8, from: [*c]u8) ?*anyopaque; +pub extern fn convert_setup(vcp: [*c]vimconv_T, from: [*c]u8, to: [*c]u8) c_int; +pub extern fn convert_setup_ext(vcp: [*c]vimconv_T, from: [*c]u8, from_unicode_is_utf8: bool, to: [*c]u8, to_unicode_is_utf8: bool) c_int; +pub extern fn string_convert(vcp: [*c]const vimconv_T, ptr: [*c]u8, lenp: [*c]usize) [*c]u8; +pub extern fn string_convert_ext(vcp: [*c]const vimconv_T, ptr: [*c]u8, lenp: [*c]usize, unconvlenp: [*c]usize) [*c]u8; +pub extern fn f_setcellwidths(argvars: [*c]typval_T, rettv: [*c]typval_T, fptr: EvalFuncData) void; +pub extern fn f_getcellwidths(argvars: [*c]typval_T, rettv: [*c]typval_T, fptr: EvalFuncData) void; +pub extern fn f_charclass(argvars: [*c]typval_T, rettv: [*c]typval_T, fptr: EvalFuncData) void; +pub fn mb_strcmp_ic(arg_ic: bool, arg_s1: [*c]const u8, arg_s2: [*c]const u8) callconv(.C) c_int { + var ic = arg_ic; + var s1 = arg_s1; + var s2 = arg_s2; + return if (@as(c_int, @boolToInt(ic)) != 0) mb_stricmp(s1, s2) else strcmp(s1, s2); +} +pub const MENU_INDEX_INVALID: c_int = -1; +pub const MENU_INDEX_NORMAL: c_int = 0; +pub const MENU_INDEX_VISUAL: c_int = 1; +pub const MENU_INDEX_SELECT: c_int = 2; +pub const MENU_INDEX_OP_PENDING: c_int = 3; +pub const MENU_INDEX_INSERT: c_int = 4; +pub const MENU_INDEX_CMDLINE: c_int = 5; +pub const MENU_INDEX_TERMINAL: c_int = 6; +pub const MENU_INDEX_TIP: c_int = 7; +pub const MENU_MODES: c_int = 8; +const enum_unnamed_118 = c_int; +pub const MENU_NORMAL_MODE: c_int = 1; +pub const MENU_VISUAL_MODE: c_int = 2; +pub const MENU_SELECT_MODE: c_int = 4; +pub const MENU_OP_PENDING_MODE: c_int = 8; +pub const MENU_INSERT_MODE: c_int = 16; +pub const MENU_CMDLINE_MODE: c_int = 32; +pub const MENU_TERMINAL_MODE: c_int = 64; +pub const MENU_TIP_MODE: c_int = 128; +pub const MENU_ALL_MODES: c_int = 127; +const enum_unnamed_119 = c_uint; +pub const vimmenu_T = struct_VimMenu; +pub const struct_VimMenu = extern struct { + modes: c_int, + enabled: c_int, + name: [*c]u8, + dname: [*c]u8, + en_name: [*c]u8, + en_dname: [*c]u8, + mnemonic: c_int, + actext: [*c]u8, + priority: c_long, + strings: [8][*c]u8, + noremap: [8]c_int, + silent: [8]bool, + children: [*c]vimmenu_T, + parent: [*c]vimmenu_T, + next: [*c]vimmenu_T, +}; +pub const AutoCmd = struct_AutoCmd_S; +pub const struct_AutoCmd_S = extern struct { + exec: AucmdExecutable, + once: bool, + nested: bool, + last: bool, + id: i64, + script_ctx: sctx_T, + desc: [*c]u8, + next: [*c]AutoCmd, +}; +pub const struct_AutoPat_S = extern struct { + next: [*c]AutoPat, + pat: [*c]u8, + reg_prog: [*c]regprog_T, + cmds: [*c]AutoCmd, + group: c_int, + patlen: c_int, + buflocal_nr: c_int, + allow_dirs: u8, + last: u8, +}; +pub const AutoPat = struct_AutoPat_S; +pub const EVENT_BUFADD: c_int = 0; +pub const EVENT_BUFDELETE: c_int = 1; +pub const EVENT_BUFENTER: c_int = 2; +pub const EVENT_BUFFILEPOST: c_int = 3; +pub const EVENT_BUFFILEPRE: c_int = 4; +pub const EVENT_BUFHIDDEN: c_int = 5; +pub const EVENT_BUFLEAVE: c_int = 6; +pub const EVENT_BUFMODIFIEDSET: c_int = 7; +pub const EVENT_BUFNEW: c_int = 8; +pub const EVENT_BUFNEWFILE: c_int = 9; +pub const EVENT_BUFREADCMD: c_int = 10; +pub const EVENT_BUFREADPOST: c_int = 11; +pub const EVENT_BUFREADPRE: c_int = 12; +pub const EVENT_BUFUNLOAD: c_int = 13; +pub const EVENT_BUFWINENTER: c_int = 14; +pub const EVENT_BUFWINLEAVE: c_int = 15; +pub const EVENT_BUFWIPEOUT: c_int = 16; +pub const EVENT_BUFWRITECMD: c_int = 17; +pub const EVENT_BUFWRITEPOST: c_int = 18; +pub const EVENT_BUFWRITEPRE: c_int = 19; +pub const EVENT_CHANINFO: c_int = 20; +pub const EVENT_CHANOPEN: c_int = 21; +pub const EVENT_CMDUNDEFINED: c_int = 22; +pub const EVENT_CMDWINENTER: c_int = 23; +pub const EVENT_CMDWINLEAVE: c_int = 24; +pub const EVENT_CMDLINECHANGED: c_int = 25; +pub const EVENT_CMDLINEENTER: c_int = 26; +pub const EVENT_CMDLINELEAVE: c_int = 27; +pub const EVENT_COLORSCHEME: c_int = 28; +pub const EVENT_COLORSCHEMEPRE: c_int = 29; +pub const EVENT_COMPLETECHANGED: c_int = 30; +pub const EVENT_COMPLETEDONE: c_int = 31; +pub const EVENT_COMPLETEDONEPRE: c_int = 32; +pub const EVENT_CURSORHOLD: c_int = 33; +pub const EVENT_CURSORHOLDI: c_int = 34; +pub const EVENT_CURSORMOVED: c_int = 35; +pub const EVENT_CURSORMOVEDI: c_int = 36; +pub const EVENT_DIAGNOSTICCHANGED: c_int = 37; +pub const EVENT_DIFFUPDATED: c_int = 38; +pub const EVENT_DIRCHANGED: c_int = 39; +pub const EVENT_DIRCHANGEDPRE: c_int = 40; +pub const EVENT_ENCODINGCHANGED: c_int = 41; +pub const EVENT_EXITPRE: c_int = 42; +pub const EVENT_FILEAPPENDCMD: c_int = 43; +pub const EVENT_FILEAPPENDPOST: c_int = 44; +pub const EVENT_FILEAPPENDPRE: c_int = 45; +pub const EVENT_FILECHANGEDRO: c_int = 46; +pub const EVENT_FILECHANGEDSHELL: c_int = 47; +pub const EVENT_FILECHANGEDSHELLPOST: c_int = 48; +pub const EVENT_FILEREADCMD: c_int = 49; +pub const EVENT_FILEREADPOST: c_int = 50; +pub const EVENT_FILEREADPRE: c_int = 51; +pub const EVENT_FILETYPE: c_int = 52; +pub const EVENT_FILEWRITECMD: c_int = 53; +pub const EVENT_FILEWRITEPOST: c_int = 54; +pub const EVENT_FILEWRITEPRE: c_int = 55; +pub const EVENT_FILTERREADPOST: c_int = 56; +pub const EVENT_FILTERREADPRE: c_int = 57; +pub const EVENT_FILTERWRITEPOST: c_int = 58; +pub const EVENT_FILTERWRITEPRE: c_int = 59; +pub const EVENT_FOCUSGAINED: c_int = 60; +pub const EVENT_FOCUSLOST: c_int = 61; +pub const EVENT_FUNCUNDEFINED: c_int = 62; +pub const EVENT_GUIENTER: c_int = 63; +pub const EVENT_GUIFAILED: c_int = 64; +pub const EVENT_INSERTCHANGE: c_int = 65; +pub const EVENT_INSERTCHARPRE: c_int = 66; +pub const EVENT_INSERTENTER: c_int = 67; +pub const EVENT_INSERTLEAVE: c_int = 68; +pub const EVENT_INSERTLEAVEPRE: c_int = 69; +pub const EVENT_LSPATTACH: c_int = 70; +pub const EVENT_LSPDETACH: c_int = 71; +pub const EVENT_LSPTOKENUPDATE: c_int = 72; +pub const EVENT_MENUPOPUP: c_int = 73; +pub const EVENT_MODECHANGED: c_int = 74; +pub const EVENT_OPTIONSET: c_int = 75; +pub const EVENT_QUICKFIXCMDPOST: c_int = 76; +pub const EVENT_QUICKFIXCMDPRE: c_int = 77; +pub const EVENT_QUITPRE: c_int = 78; +pub const EVENT_RECORDINGENTER: c_int = 79; +pub const EVENT_RECORDINGLEAVE: c_int = 80; +pub const EVENT_REMOTEREPLY: c_int = 81; +pub const EVENT_SEARCHWRAPPED: c_int = 82; +pub const EVENT_SESSIONLOADPOST: c_int = 83; +pub const EVENT_SHELLCMDPOST: c_int = 84; +pub const EVENT_SHELLFILTERPOST: c_int = 85; +pub const EVENT_SIGNAL: c_int = 86; +pub const EVENT_SOURCECMD: c_int = 87; +pub const EVENT_SOURCEPOST: c_int = 88; +pub const EVENT_SOURCEPRE: c_int = 89; +pub const EVENT_SPELLFILEMISSING: c_int = 90; +pub const EVENT_STDINREADPOST: c_int = 91; +pub const EVENT_STDINREADPRE: c_int = 92; +pub const EVENT_SWAPEXISTS: c_int = 93; +pub const EVENT_SYNTAX: c_int = 94; +pub const EVENT_TABCLOSED: c_int = 95; +pub const EVENT_TABENTER: c_int = 96; +pub const EVENT_TABLEAVE: c_int = 97; +pub const EVENT_TABNEW: c_int = 98; +pub const EVENT_TABNEWENTERED: c_int = 99; +pub const EVENT_TERMCHANGED: c_int = 100; +pub const EVENT_TERMCLOSE: c_int = 101; +pub const EVENT_TERMENTER: c_int = 102; +pub const EVENT_TERMLEAVE: c_int = 103; +pub const EVENT_TERMOPEN: c_int = 104; +pub const EVENT_TERMRESPONSE: c_int = 105; +pub const EVENT_TEXTCHANGED: c_int = 106; +pub const EVENT_TEXTCHANGEDI: c_int = 107; +pub const EVENT_TEXTCHANGEDP: c_int = 108; +pub const EVENT_TEXTCHANGEDT: c_int = 109; +pub const EVENT_TEXTYANKPOST: c_int = 110; +pub const EVENT_UIENTER: c_int = 111; +pub const EVENT_UILEAVE: c_int = 112; +pub const EVENT_USER: c_int = 113; +pub const EVENT_VIMENTER: c_int = 114; +pub const EVENT_VIMLEAVE: c_int = 115; +pub const EVENT_VIMLEAVEPRE: c_int = 116; +pub const EVENT_VIMRESIZED: c_int = 117; +pub const EVENT_VIMRESUME: c_int = 118; +pub const EVENT_VIMSUSPEND: c_int = 119; +pub const EVENT_WINCLOSED: c_int = 120; +pub const EVENT_WINENTER: c_int = 121; +pub const EVENT_WINLEAVE: c_int = 122; +pub const EVENT_WINNEW: c_int = 123; +pub const EVENT_WINRESIZED: c_int = 124; +pub const EVENT_WINSCROLLED: c_int = 125; +pub const NUM_EVENTS: c_int = 126; +pub const enum_auto_event = c_uint; +pub const event_T = enum_auto_event; +pub const AutoPatCmd = struct_AutoPatCmd_S; +pub const struct_AutoPatCmd_S = extern struct { + curpat: [*c]AutoPat, + nextcmd: [*c]AutoCmd, + group: c_int, + fname: [*c]u8, + sfname: [*c]u8, + tail: [*c]u8, + event: event_T, + script_ctx: sctx_T, + arg_bufnr: c_int, + data: [*c]Object, + next: [*c]AutoPatCmd, +}; +pub const aco_save_T = extern struct { + save_curbuf: [*c]buf_T, + use_aucmd_win_idx: c_int, + save_curwin_handle: handle_T, + new_curwin_handle: handle_T, + save_prevwin_handle: handle_T, + new_curbuf: bufref_T, + globaldir: [*c]u8, + save_VIsual_active: bool, + save_State: c_int, +}; +pub extern var au_did_filetype: bool; +pub extern fn aupat_del_for_event_and_group(event: event_T, group: c_int) void; +pub extern fn au_get_autopat_for_event(event: event_T) [*c]AutoPat; +pub extern fn aubuflocal_remove(buf: [*c]buf_T) void; +pub extern fn augroup_add(name: [*c]u8) c_int; +pub extern fn augroup_del(name: [*c]u8, stupid_legacy_mode: bool) void; +pub extern fn augroup_find(name: [*c]const u8) c_int; +pub extern fn augroup_name(group: c_int) [*c]u8; +pub extern fn augroup_exists(name: [*c]const u8) bool; +pub extern fn do_augroup(arg: [*c]u8, del_group: c_int) void; +pub extern fn is_aucmd_win(win: [*c]win_T) bool; +pub extern fn event_name2nr(start: [*c]const u8, end: [*c][*c]u8) event_T; +pub extern fn event_nr2name(event: event_T) [*c]const u8; +pub extern fn check_ei() c_int; +pub extern fn au_event_disable(what: [*c]u8) [*c]u8; +pub extern fn au_event_restore(old_ei: [*c]u8) void; +pub extern fn do_autocmd(eap: [*c]exarg_T, arg_in: [*c]u8, forceit: c_int) void; +pub extern fn do_all_autocmd_events(pat: [*c]u8, once: bool, nested: c_int, cmd: [*c]u8, del: bool, group: c_int) void; +pub extern fn do_autocmd_event(event: event_T, pat: [*c]u8, once: bool, nested: c_int, cmd: [*c]u8, del: bool, group: c_int) c_int; +pub extern fn autocmd_register(id: i64, event: event_T, pat: [*c]u8, patlen: c_int, group: c_int, once: bool, nested: bool, desc: [*c]u8, aucmd: AucmdExecutable) c_int; +pub extern fn aucmd_pattern_length(pat: [*c]u8) usize; +pub extern fn aucmd_next_pattern(pat: [*c]u8, patlen: usize) [*c]u8; +pub extern fn do_doautocmd(arg_start: [*c]u8, do_msg: bool, did_something: [*c]bool) c_int; +pub extern fn ex_doautoall(eap: [*c]exarg_T) void; +pub extern fn check_nomodeline(argp: [*c][*c]u8) bool; +pub extern fn aucmd_prepbuf(aco: [*c]aco_save_T, buf: [*c]buf_T) void; +pub extern fn aucmd_restbuf(aco: [*c]aco_save_T) void; +pub extern fn apply_autocmds(event: event_T, fname: [*c]u8, fname_io: [*c]u8, force: bool, buf: [*c]buf_T) bool; +pub extern fn apply_autocmds_exarg(event: event_T, fname: [*c]u8, fname_io: [*c]u8, force: bool, buf: [*c]buf_T, eap: [*c]exarg_T) bool; +pub extern fn apply_autocmds_retval(event: event_T, fname: [*c]u8, fname_io: [*c]u8, force: bool, buf: [*c]buf_T, retval: [*c]c_int) bool; +pub extern fn has_event(event: event_T) bool; +pub extern fn has_cursorhold() bool; +pub extern fn trigger_cursorhold() bool; +pub extern fn apply_autocmds_group(event: event_T, fname: [*c]u8, fname_io: [*c]u8, force: bool, group: c_int, buf: [*c]buf_T, eap: [*c]exarg_T, data: [*c]Object) bool; +pub extern fn block_autocmds() void; +pub extern fn unblock_autocmds() void; +pub extern fn is_autocmd_blocked() bool; +pub extern fn auto_next_pat(apc: [*c]AutoPatCmd, stop_at_last: c_int) void; +pub extern fn getnextac(c: c_int, cookie: ?*anyopaque, indent: c_int, do_concat: bool) [*c]u8; +pub extern fn has_autocmd(event: event_T, sfname: [*c]u8, buf: [*c]buf_T) bool; +pub extern fn expand_get_augroup_name(xp: [*c]expand_T, idx: c_int) [*c]u8; +pub extern fn set_context_in_autocmd(xp: [*c]expand_T, arg: [*c]u8, doautocmd: c_int) [*c]u8; +pub extern fn expand_get_event_name(xp: [*c]expand_T, idx: c_int) [*c]u8; +pub extern fn autocmd_supported(event: [*c]const u8) bool; +pub extern fn au_exists(arg: [*c]const u8) bool; +pub extern fn aupat_is_buflocal(pat: [*c]u8, patlen: c_int) bool; +pub extern fn aupat_get_buflocal_nr(pat: [*c]u8, patlen: c_int) c_int; +pub extern fn aupat_normalize_buflocal_pat(dest: [*c]u8, pat: [*c]u8, patlen: c_int, buflocal_nr: c_int) void; +pub extern fn autocmd_delete_event(group: c_int, event: event_T, pat: [*c]u8) c_int; +pub extern fn autocmd_delete_id(id: i64) bool; +pub extern fn aucmd_exec_to_string(ac: [*c]AutoCmd, acc: AucmdExecutable) [*c]u8; +pub extern fn aucmd_exec_free(acc: [*c]AucmdExecutable) void; +pub extern fn aucmd_exec_copy(src: AucmdExecutable) AucmdExecutable; +pub extern fn aucmd_exec_is_deleted(acc: AucmdExecutable) bool; +pub extern fn au_event_is_empty(event: event_T) bool; +pub extern fn do_autocmd_uienter(chanid: u64, attached: bool) void; +pub extern fn do_autocmd_focusgained(gained: bool) void; +pub extern fn do_filetype_autocmd(buf: [*c]buf_T, force: bool) void; +pub const ETYPE_TOP: c_int = 0; +pub const ETYPE_SCRIPT: c_int = 1; +pub const ETYPE_UFUNC: c_int = 2; +pub const ETYPE_AUCMD: c_int = 3; +pub const ETYPE_MODELINE: c_int = 4; +pub const ETYPE_EXCEPT: c_int = 5; +pub const ETYPE_ARGS: c_int = 6; +pub const ETYPE_ENV: c_int = 7; +pub const ETYPE_INTERNAL: c_int = 8; +pub const ETYPE_SPELL: c_int = 9; +pub const etype_T = c_uint; +const union_unnamed_120 = extern union { + sctx: [*c]sctx_T, + ufunc: [*c]ufunc_T, + aucmd: [*c]AutoPatCmd, + except: [*c]except_T, +}; +pub const estack_T = extern struct { + es_lnum: linenr_T, + es_name: [*c]u8, + es_type: etype_T, + es_info: union_unnamed_120, +}; +pub extern var exestack: garray_T; +pub const ESTACK_NONE: c_int = 0; +pub const ESTACK_SFILE: c_int = 1; +pub const ESTACK_STACK: c_int = 2; +pub const ESTACK_SCRIPT: c_int = 3; +pub const estack_arg_T = c_uint; +pub const scriptvar_T = extern struct { + sv_var: ScopeDictDictItem, + sv_dict: dict_T, +}; +pub const scriptitem_T = extern struct { + sn_vars: [*c]scriptvar_T, + sn_name: [*c]u8, + sn_prof_on: bool, + sn_pr_force: bool, + sn_pr_child: proftime_T, + sn_pr_nest: c_int, + sn_pr_count: c_int, + sn_pr_total: proftime_T, + sn_pr_self: proftime_T, + sn_pr_start: proftime_T, + sn_pr_children: proftime_T, + sn_prl_ga: garray_T, + sn_prl_start: proftime_T, + sn_prl_children: proftime_T, + sn_prl_wait: proftime_T, + sn_prl_idx: linenr_T, + sn_prl_execed: c_int, +}; +pub extern var script_items: garray_T; +pub const DoInRuntimepathCB = ?*const fn ([*c]u8, ?*anyopaque) callconv(.C) void; +pub const SearchPathItem = extern struct { + path: [*c]u8, + after: bool, + has_lua: TriState, +}; +pub const RuntimeSearchPath = extern struct { + size: usize, + capacity: usize, + items: [*c]SearchPathItem, +}; +pub const CharVec = extern struct { + size: usize, + capacity: usize, + items: [*c][*c]u8, +}; +pub extern fn estack_init() void; +pub extern fn estack_push(@"type": etype_T, name: [*c]u8, lnum: linenr_T) [*c]estack_T; +pub extern fn estack_push_ufunc(ufunc: [*c]ufunc_T, lnum: linenr_T) void; +pub extern fn estack_pop() void; +pub extern fn estack_sfile(which: estack_arg_T) [*c]u8; +pub extern fn runtime_init() void; +pub extern fn ex_runtime(eap: [*c]exarg_T) void; +pub extern fn set_context_in_runtime_cmd(xp: [*c]expand_T, arg: [*c]const u8) void; +pub extern fn do_in_path(path: [*c]u8, name: [*c]u8, flags: c_int, callback: DoInRuntimepathCB, cookie: ?*anyopaque) c_int; +pub extern fn runtime_search_path_get_cached(ref: [*c]c_int) RuntimeSearchPath; +pub extern fn copy_runtime_search_path(src: RuntimeSearchPath) RuntimeSearchPath; +pub extern fn runtime_search_path_unref(path: RuntimeSearchPath, ref: [*c]const c_int) void; +pub extern fn do_in_cached_path(name: [*c]u8, flags: c_int, callback: DoInRuntimepathCB, cookie: ?*anyopaque) c_int; +pub extern fn runtime_inspect() Array; +pub extern fn runtime_get_named(lua: bool, pat: Array, all: bool) Array; +pub extern fn runtime_get_named_thread(lua: bool, pat: Array, all: bool) Array; +pub extern fn runtime_get_named_common(lua: bool, pat: Array, all: bool, path: RuntimeSearchPath, buf: [*c]u8, buf_len: usize) Array; +pub extern fn do_in_path_and_pp(path: [*c]u8, name: [*c]u8, flags: c_int, callback: DoInRuntimepathCB, cookie: ?*anyopaque) c_int; +pub extern fn runtime_search_path_build() RuntimeSearchPath; +pub extern fn runtime_search_path_invalidate() void; +pub extern fn runtime_search_path_free(path: RuntimeSearchPath) void; +pub extern fn runtime_search_path_validate() void; +pub extern fn do_in_runtimepath(name: [*c]u8, flags: c_int, callback: DoInRuntimepathCB, cookie: ?*anyopaque) c_int; +pub extern fn source_runtime(name: [*c]u8, flags: c_int) c_int; +pub extern fn source_in_path(path: [*c]u8, name: [*c]u8, flags: c_int) c_int; +pub extern fn add_pack_start_dirs() void; +pub extern fn load_start_packages() void; +pub extern fn ex_packloadall(eap: [*c]exarg_T) void; +pub extern fn load_plugins() void; +pub extern fn ex_packadd(eap: [*c]exarg_T) void; +pub extern fn ExpandRTDir(pat: [*c]u8, flags: c_int, num_file: [*c]c_int, file: [*c][*c][*c]u8, dirnames: [*c][*c]u8) c_int; +pub extern fn expand_runtime_cmd(pat: [*c]u8, numMatches: [*c]c_int, matches: [*c][*c][*c]u8) c_int; +pub extern fn ExpandPackAddDir(pat: [*c]u8, num_file: [*c]c_int, file: [*c][*c][*c]u8) c_int; +pub extern fn get_lib_dir() [*c]u8; +pub extern fn runtimepath_default(clean_arg: bool) [*c]u8; +pub extern fn ex_source(eap: [*c]exarg_T) void; +pub extern fn ex_options(eap: [*c]exarg_T) void; +pub extern fn source_breakpoint(cookie: ?*anyopaque) [*c]linenr_T; +pub extern fn source_dbg_tick(cookie: ?*anyopaque) [*c]c_int; +pub extern fn source_level(cookie: ?*anyopaque) c_int; +pub extern fn new_script_item(name: [*c]u8, sid_out: [*c]scid_T) [*c]scriptitem_T; +pub extern fn do_source_str(cmd: [*c]const u8, traceback_name: [*c]const u8) c_int; +pub extern fn do_source(fname: [*c]u8, check_other: c_int, is_vimrc: c_int, ret_sid: [*c]c_int) c_int; +pub extern fn find_script_by_name(name: [*c]u8) c_int; +pub extern fn ex_scriptnames(eap: [*c]exarg_T) void; +pub extern fn get_scriptname(last_set: LastSet, should_free: [*c]bool) [*c]u8; +pub extern fn free_autoload_scriptnames() void; +pub extern fn get_sourced_lnum(fgetline: LineGetter, cookie: ?*anyopaque) linenr_T; +pub extern fn f_getscriptinfo(argvars: [*c]typval_T, rettv: [*c]typval_T, fptr: EvalFuncData) void; +pub extern fn getsourceline(c: c_int, cookie: ?*anyopaque, indent: c_int, do_concat: bool) [*c]u8; +pub extern fn ex_scriptencoding(eap: [*c]exarg_T) void; +pub extern fn ex_finish(eap: [*c]exarg_T) void; +pub extern fn do_finish(eap: [*c]exarg_T, reanimate: c_int) void; +pub extern fn source_finished(fgetline: LineGetter, cookie: ?*anyopaque) bool; +pub extern fn autoload_name(name: [*c]const u8, name_len: usize) [*c]u8; +pub extern fn script_autoload(name: [*c]const u8, name_len: usize, reload: bool) bool; +pub const struct_nvim_stats_s = extern struct { + fsync: i64, + redraw: i64, + log_skip: i16, +}; +pub extern var g_stats: struct_nvim_stats_s; +pub extern var Rows: c_int; +pub extern var Columns: c_int; +pub const off_T = off_t; +pub extern var mod_mask: c_int; +pub extern var vgetc_mod_mask: c_int; +pub extern var vgetc_char: c_int; +pub extern var cmdline_row: c_int; +pub extern var redraw_cmdline: bool; +pub extern var redraw_mode: bool; +pub extern var clear_cmdline: bool; +pub extern var mode_displayed: bool; +pub extern var cmdline_star: c_int; +pub extern var redrawing_cmdline: bool; +pub extern var cmdline_was_last_drawn: bool; +pub extern var exec_from_reg: bool; +pub extern var dollar_vcol: colnr_T; +pub extern var edit_submode: [*c]u8; +pub extern var edit_submode_pre: [*c]u8; +pub extern var edit_submode_extra: [*c]u8; +pub extern var edit_submode_highl: hlf_T; +pub extern var cmdmsg_rl: bool; +pub extern var msg_col: c_int; +pub extern var msg_row: c_int; +pub extern var msg_scrolled: c_int; +pub extern var msg_scrolled_ign: bool; +pub extern var msg_did_scroll: bool; +pub extern var keep_msg: [*c]u8; +pub extern var keep_msg_attr: c_int; +pub extern var need_fileinfo: bool; +pub extern var msg_scroll: c_int; +pub extern var msg_didout: bool; +pub extern var msg_didany: bool; +pub extern var msg_nowait: bool; +pub extern var emsg_off: c_int; +pub extern var info_message: bool; +pub extern var msg_hist_off: bool; +pub extern var need_clr_eos: bool; +pub extern var emsg_skip: c_int; +pub extern var emsg_severe: bool; +pub extern var emsg_assert_fails_msg: [*c]u8; +pub extern var emsg_assert_fails_lnum: c_long; +pub extern var emsg_assert_fails_context: [*c]u8; +pub extern var did_endif: bool; +pub extern var vimvardict: dict_T; +pub extern var globvardict: dict_T; +pub extern var did_emsg: c_int; +pub extern var called_vim_beep: bool; +pub extern var did_emsg_syntax: bool; +pub extern var called_emsg: c_int; +pub extern var ex_exitval: c_int; +pub extern var emsg_on_display: bool; +pub extern var rc_did_emsg: bool; +pub extern var no_wait_return: c_int; +pub extern var need_wait_return: bool; +pub extern var did_wait_return: bool; +pub extern var need_maketitle: bool; +pub extern var quit_more: bool; +pub extern var vgetc_busy: c_int; +pub extern var didset_vim: bool; +pub extern var didset_vimruntime: bool; +pub extern var lines_left: c_int; +pub extern var msg_no_more: bool; +pub extern var ex_nesting_level: c_int; +pub extern var debug_break_level: c_int; +pub extern var debug_did_msg: bool; +pub extern var debug_tick: c_int; +pub extern var debug_backtrace_level: c_int; +pub extern var do_profiling: c_int; +pub extern var current_exception: [*c]except_T; +pub extern var did_throw: bool; +pub extern var need_rethrow: bool; +pub extern var check_cstack: bool; +pub extern var trylevel: c_int; +pub extern var force_abort: bool; +pub extern var msg_list: [*c][*c]msglist_T; +pub extern var suppress_errthrow: bool; +pub extern var caught_stack: [*c]except_T; +pub extern var may_garbage_collect: bool; +pub extern var want_garbage_collect: bool; +pub extern var garbage_collect_at_exit: bool; +pub extern var current_sctx: sctx_T; +pub extern var current_channel_id: u64; +pub extern var did_source_packages: bool; +pub const struct_caller_scope = extern struct { + script_ctx: sctx_T, + es_entry: estack_T, + autocmd_fname: [*c]u8, + autocmd_match: [*c]u8, + autocmd_bufnr: c_int, + funccalp: ?*anyopaque, +}; +pub extern var provider_caller_scope: struct_caller_scope; +pub extern var provider_call_nesting: c_int; +pub extern var t_colors: c_int; +pub extern var include_none: c_int; +pub extern var include_default: c_int; +pub extern var include_link: c_int; +pub extern var highlight_match: bool; +pub extern var search_match_lines: linenr_T; +pub extern var search_match_endcol: colnr_T; +pub extern var search_first_line: linenr_T; +pub extern var search_last_line: linenr_T; +pub extern var no_smartcase: bool; +pub extern var need_check_timestamps: bool; +pub extern var did_check_timestamps: bool; +pub extern var no_check_timestamps: c_int; +pub extern var autocmd_busy: bool; +pub extern var autocmd_no_enter: c_int; +pub extern var autocmd_no_leave: c_int; +pub extern var modified_was_set: c_int; +pub extern var did_filetype: bool; +pub extern var keep_filetype: bool; +pub extern var au_new_curbuf: bufref_T; +pub extern var au_pending_free_buf: [*c]buf_T; +pub extern var au_pending_free_win: [*c]win_T; +pub extern var mouse_grid: c_int; +pub extern var mouse_row: c_int; +pub extern var mouse_col: c_int; +pub extern var mouse_past_bottom: bool; +pub extern var mouse_past_eol: bool; +pub extern var mouse_dragging: c_int; +pub extern var root_menu: [*c]vimmenu_T; +pub extern var sys_menu: bool; +pub extern var firstwin: [*c]win_T; +pub extern var lastwin: [*c]win_T; +pub extern var prevwin: [*c]win_T; +pub extern var curwin: [*c]win_T; +pub const aucmdwin_T = extern struct { + auc_win: [*c]win_T, + auc_win_used: bool, +}; +const struct_unnamed_121 = extern struct { + size: usize, + capacity: usize, + items: [*c]aucmdwin_T, +}; +pub extern var aucmd_win_vec: struct_unnamed_121; +pub extern var topframe: [*c]frame_T; +pub extern var first_tabpage: [*c]tabpage_T; +pub extern var curtab: [*c]tabpage_T; +pub extern var lastused_tabpage: [*c]tabpage_T; +pub extern var redraw_tabline: bool; +pub extern var firstbuf: [*c]buf_T; +pub extern var lastbuf: [*c]buf_T; +pub extern var curbuf: [*c]buf_T; +pub extern var global_alist: alist_T; +pub extern var max_alist_id: c_int; +pub extern var arg_had_last: bool; +pub extern var ru_col: c_int; +pub extern var ru_wid: c_int; +pub extern var sc_col: c_int; +pub extern var starting: c_int; +pub extern var exiting: bool; +pub extern var v_dying: c_int; +pub extern var stdin_isatty: bool; +pub extern var stdout_isatty: bool; +pub extern var stderr_isatty: bool; +pub extern var stdin_fd: c_int; +pub extern var full_screen: bool; +pub extern var secure: c_int; +pub extern var textlock: c_int; +pub extern var allbuf_lock: c_int; +pub extern var sandbox: c_int; +pub extern var silent_mode: bool; +pub extern var VIsual: pos_T; +pub extern var VIsual_active: bool; +pub extern var VIsual_select: bool; +pub extern var VIsual_select_reg: c_int; +pub extern var restart_VIsual_select: c_int; +pub extern var VIsual_reselect: c_int; +pub extern var VIsual_mode: c_int; +pub extern var redo_VIsual_busy: bool; +pub extern var resel_VIsual_mode: c_int; +pub extern var resel_VIsual_line_count: linenr_T; +pub extern var resel_VIsual_vcol: colnr_T; +pub extern var where_paste_started: pos_T; +pub extern var did_ai: bool; +pub extern var ai_col: colnr_T; +pub extern var end_comment_pending: c_int; +pub extern var did_syncbind: bool; +pub extern var did_si: bool; +pub extern var can_si: bool; +pub extern var can_si_back: bool; +pub extern var old_indent: c_int; +pub extern var saved_cursor: pos_T; +pub extern var Insstart: pos_T; +pub extern var Insstart_orig: pos_T; +pub extern var orig_line_count: linenr_T; +pub extern var vr_lines_changed: c_int; +pub extern var inhibit_delete_count: c_int; +pub extern var fenc_default: [*c]u8; +pub extern var State: c_int; +pub extern var debug_mode: bool; +pub extern var finish_op: bool; +pub extern var opcount: c_long; +pub extern var motion_force: c_int; +pub extern var exmode_active: bool; +pub extern var pending_exmode_active: bool; +pub extern var ex_no_reprint: bool; +pub extern var cmdpreview: bool; +pub extern var reg_recording: c_int; +pub extern var reg_executing: c_int; +pub extern var pending_end_reg_executing: bool; +pub extern var reg_recorded: c_int; +pub extern var no_mapping: c_int; +pub extern var no_zero_mapping: c_int; +pub extern var allow_keys: c_int; +pub extern var no_u_sync: c_int; +pub extern var u_sync_once: c_int; +pub extern var force_restart_edit: bool; +pub extern var restart_edit: c_int; +pub extern var arrow_used: c_int; +pub extern var ins_at_eol: bool; +pub extern var no_abbr: bool; +pub extern var mapped_ctrl_c: c_int; +pub extern var ctrl_c_interrupts: bool; +pub extern var cmdmod: cmdmod_T; +pub extern var msg_silent: c_int; +pub extern var emsg_silent: c_int; +pub extern var emsg_noredir: bool; +pub extern var cmd_silent: bool; +pub extern var in_assert_fails: bool; +pub extern var swap_exists_action: c_int; +pub extern var swap_exists_did_quit: bool; +pub extern var IObuff: [1025]u8; +pub extern var NameBuff: [4096]u8; +pub extern var msg_buf: [480]u8; +pub extern var os_buf: [4096]u8; +pub extern var RedrawingDisabled: c_int; +pub extern var readonlymode: bool; +pub extern var recoverymode: bool; +pub extern var typebuf: typebuf_T; +pub extern var typebuf_was_empty: bool; +pub extern var ex_normal_busy: c_int; +pub extern var expr_map_lock: c_int; +pub extern var ignore_script: bool; +pub extern var stop_insert_mode: c_int; +pub extern var KeyTyped: bool; +pub extern var KeyStuffed: c_int; +pub extern var maptick: c_int; +pub extern var must_redraw: c_int; +pub extern var skip_redraw: bool; +pub extern var do_redraw: bool; +pub extern var must_redraw_pum: bool; +pub extern var need_highlight_changed: bool; +pub extern var scriptout: [*c]FILE; +pub extern var got_int: bool; +pub extern var bangredo: bool; +pub extern var searchcmdlen: c_int; +pub extern var reg_do_extmatch: c_int; +pub extern var re_extmatch_in: [*c]reg_extmatch_T; +pub extern var re_extmatch_out: [*c]reg_extmatch_T; +pub extern var did_outofmem_msg: bool; +pub extern var did_swapwrite_msg: bool; +pub extern var global_busy: c_int; +pub extern var listcmd_busy: bool; +pub extern var need_start_insertmode: bool; +pub extern var last_mode: [4]u8; +pub extern var last_cmdline: [*c]u8; +pub extern var repeat_cmdline: [*c]u8; +pub extern var new_last_cmdline: [*c]u8; +pub extern var autocmd_fname: [*c]u8; +pub extern var autocmd_bufnr: c_int; +pub extern var autocmd_match: [*c]u8; +pub extern var did_cursorhold: bool; +pub extern var postponed_split: c_int; +pub extern var postponed_split_flags: c_int; +pub extern var postponed_split_tab: c_int; +pub extern var g_do_tagpreview: c_int; +pub extern var g_tag_at_cursor: bool; +pub extern var replace_offset: c_int; +pub extern var escape_chars: [*c]u8; +pub extern var keep_help_flag: bool; +pub extern var empty_option: [*c]u8; +pub extern var redir_off: bool; +pub extern var redir_fd: [*c]FILE; +pub extern var redir_reg: c_int; +pub extern var redir_vname: c_int; +pub extern var capture_ga: [*c]garray_T; +pub extern var langmap_mapchar: [256]u8; +pub extern var save_p_ls: c_int; +pub extern var save_p_wmh: c_int; +pub extern var wild_menu_showing: c_int; +pub const WM_SHOWN: c_int = 1; +pub const WM_SCROLLED: c_int = 2; +pub const WM_LIST: c_int = 3; +const enum_unnamed_122 = c_uint; +pub extern var globaldir: [*c]u8; +pub extern var last_chdir_reason: [*c]u8; +pub extern var km_stopsel: bool; +pub extern var km_startsel: bool; +pub extern var cmdwin_type: c_int; +pub extern var cmdwin_result: c_int; +pub extern var cmdwin_level: c_int; +pub const no_lines_msg: [*c]u8 = @extern([*c]u8, .{ + .name = "no_lines_msg", +}); +pub extern var sub_nsubs: c_long; +pub extern var sub_nlines: linenr_T; +pub extern var wim_flags: [4]u8; +pub extern var stl_syntax: c_int; +pub extern var no_hlsearch: bool; +pub extern var typebuf_was_filled: bool; +pub extern var virtual_op: TriState; +pub extern var display_tick: disptick_T; +pub extern var spell_redraw_lnum: linenr_T; +pub const e_abort: [*c]const u8 = @extern([*c]const u8, .{ + .name = "e_abort", +}); +pub const e_afterinit: [*c]const u8 = @extern([*c]const u8, .{ + .name = "e_afterinit", +}); +pub const e_api_spawn_failed: [*c]const u8 = @extern([*c]const u8, .{ + .name = "e_api_spawn_failed", +}); +pub const e_argreq: [*c]const u8 = @extern([*c]const u8, .{ + .name = "e_argreq", +}); +pub const e_backslash: [*c]const u8 = @extern([*c]const u8, .{ + .name = "e_backslash", +}); +pub const e_cmdwin: [*c]const u8 = @extern([*c]const u8, .{ + .name = "e_cmdwin", +}); +pub const e_curdir: [*c]const u8 = @extern([*c]const u8, .{ + .name = "e_curdir", +}); +pub const e_command_too_recursive: [*c]const u8 = @extern([*c]const u8, .{ + .name = "e_command_too_recursive", +}); +pub const e_endif: [*c]const u8 = @extern([*c]const u8, .{ + .name = "e_endif", +}); +pub const e_endtry: [*c]const u8 = @extern([*c]const u8, .{ + .name = "e_endtry", +}); +pub const e_endwhile: [*c]const u8 = @extern([*c]const u8, .{ + .name = "e_endwhile", +}); +pub const e_endfor: [*c]const u8 = @extern([*c]const u8, .{ + .name = "e_endfor", +}); +pub const e_while: [*c]const u8 = @extern([*c]const u8, .{ + .name = "e_while", +}); +pub const e_for: [*c]const u8 = @extern([*c]const u8, .{ + .name = "e_for", +}); +pub const e_exists: [*c]const u8 = @extern([*c]const u8, .{ + .name = "e_exists", +}); +pub const e_failed: [*c]const u8 = @extern([*c]const u8, .{ + .name = "e_failed", +}); +pub const e_internal: [*c]const u8 = @extern([*c]const u8, .{ + .name = "e_internal", +}); +pub const e_intern2: [*c]const u8 = @extern([*c]const u8, .{ + .name = "e_intern2", +}); +pub const e_interr: [*c]const u8 = @extern([*c]const u8, .{ + .name = "e_interr", +}); +pub const e_invarg: [*c]const u8 = @extern([*c]const u8, .{ + .name = "e_invarg", +}); +pub const e_invarg2: [*c]const u8 = @extern([*c]const u8, .{ + .name = "e_invarg2", +}); +pub const e_invargval: [*c]const u8 = @extern([*c]const u8, .{ + .name = "e_invargval", +}); +pub const e_invargNval: [*c]const u8 = @extern([*c]const u8, .{ + .name = "e_invargNval", +}); +pub const e_duparg2: [*c]const u8 = @extern([*c]const u8, .{ + .name = "e_duparg2", +}); +pub const e_invexpr2: [*c]const u8 = @extern([*c]const u8, .{ + .name = "e_invexpr2", +}); +pub const e_invrange: [*c]const u8 = @extern([*c]const u8, .{ + .name = "e_invrange", +}); +pub const e_invcmd: [*c]const u8 = @extern([*c]const u8, .{ + .name = "e_invcmd", +}); +pub const e_isadir2: [*c]const u8 = @extern([*c]const u8, .{ + .name = "e_isadir2", +}); +pub const e_no_spell: [*c]const u8 = @extern([*c]const u8, .{ + .name = "e_no_spell", +}); +pub const e_invchan: [*c]const u8 = @extern([*c]const u8, .{ + .name = "e_invchan", +}); +pub const e_invchanjob: [*c]const u8 = @extern([*c]const u8, .{ + .name = "e_invchanjob", +}); +pub const e_jobtblfull: [*c]const u8 = @extern([*c]const u8, .{ + .name = "e_jobtblfull", +}); +pub const e_jobspawn: [*c]const u8 = @extern([*c]const u8, .{ + .name = "e_jobspawn", +}); +pub const e_channotpty: [*c]const u8 = @extern([*c]const u8, .{ + .name = "e_channotpty", +}); +pub const e_stdiochan2: [*c]const u8 = @extern([*c]const u8, .{ + .name = "e_stdiochan2", +}); +pub const e_invstream: [*c]const u8 = @extern([*c]const u8, .{ + .name = "e_invstream", +}); +pub const e_invstreamrpc: [*c]const u8 = @extern([*c]const u8, .{ + .name = "e_invstreamrpc", +}); +pub const e_streamkey: [*c]const u8 = @extern([*c]const u8, .{ + .name = "e_streamkey", +}); +pub const e_libcall: [*c]const u8 = @extern([*c]const u8, .{ + .name = "e_libcall", +}); +pub const e_fsync: [*c]const u8 = @extern([*c]const u8, .{ + .name = "e_fsync", +}); +pub const e_mkdir: [*c]const u8 = @extern([*c]const u8, .{ + .name = "e_mkdir", +}); +pub const e_markinval: [*c]const u8 = @extern([*c]const u8, .{ + .name = "e_markinval", +}); +pub const e_marknotset: [*c]const u8 = @extern([*c]const u8, .{ + .name = "e_marknotset", +}); +pub const e_modifiable: [*c]const u8 = @extern([*c]const u8, .{ + .name = "e_modifiable", +}); +pub const e_nesting: [*c]const u8 = @extern([*c]const u8, .{ + .name = "e_nesting", +}); +pub const e_noalt: [*c]const u8 = @extern([*c]const u8, .{ + .name = "e_noalt", +}); +pub const e_noabbr: [*c]const u8 = @extern([*c]const u8, .{ + .name = "e_noabbr", +}); +pub const e_nobang: [*c]const u8 = @extern([*c]const u8, .{ + .name = "e_nobang", +}); +pub const e_nogroup: [*c]const u8 = @extern([*c]const u8, .{ + .name = "e_nogroup", +}); +pub const e_noinstext: [*c]const u8 = @extern([*c]const u8, .{ + .name = "e_noinstext", +}); +pub const e_nolastcmd: [*c]const u8 = @extern([*c]const u8, .{ + .name = "e_nolastcmd", +}); +pub const e_nomap: [*c]const u8 = @extern([*c]const u8, .{ + .name = "e_nomap", +}); +pub const e_nomatch: [*c]const u8 = @extern([*c]const u8, .{ + .name = "e_nomatch", +}); +pub const e_nomatch2: [*c]const u8 = @extern([*c]const u8, .{ + .name = "e_nomatch2", +}); +pub const e_noname: [*c]const u8 = @extern([*c]const u8, .{ + .name = "e_noname", +}); +pub const e_nopresub: [*c]const u8 = @extern([*c]const u8, .{ + .name = "e_nopresub", +}); +pub const e_noprev: [*c]const u8 = @extern([*c]const u8, .{ + .name = "e_noprev", +}); +pub const e_noprevre: [*c]const u8 = @extern([*c]const u8, .{ + .name = "e_noprevre", +}); +pub const e_norange: [*c]const u8 = @extern([*c]const u8, .{ + .name = "e_norange", +}); +pub const e_noroom: [*c]const u8 = @extern([*c]const u8, .{ + .name = "e_noroom", +}); +pub const e_notmp: [*c]const u8 = @extern([*c]const u8, .{ + .name = "e_notmp", +}); +pub const e_notopen: [*c]const u8 = @extern([*c]const u8, .{ + .name = "e_notopen", +}); +pub const e_notopen_2: [*c]const u8 = @extern([*c]const u8, .{ + .name = "e_notopen_2", +}); +pub const e_notread: [*c]const u8 = @extern([*c]const u8, .{ + .name = "e_notread", +}); +pub const e_null: [*c]const u8 = @extern([*c]const u8, .{ + .name = "e_null", +}); +pub const e_number_exp: [*c]const u8 = @extern([*c]const u8, .{ + .name = "e_number_exp", +}); +pub const e_openerrf: [*c]const u8 = @extern([*c]const u8, .{ + .name = "e_openerrf", +}); +pub const e_outofmem: [*c]const u8 = @extern([*c]const u8, .{ + .name = "e_outofmem", +}); +pub const e_patnotf: [*c]const u8 = @extern([*c]const u8, .{ + .name = "e_patnotf", +}); +pub const e_patnotf2: [*c]const u8 = @extern([*c]const u8, .{ + .name = "e_patnotf2", +}); +pub const e_positive: [*c]const u8 = @extern([*c]const u8, .{ + .name = "e_positive", +}); +pub const e_prev_dir: [*c]const u8 = @extern([*c]const u8, .{ + .name = "e_prev_dir", +}); +pub const e_no_errors: [*c]const u8 = @extern([*c]const u8, .{ + .name = "e_no_errors", +}); +pub const e_loclist: [*c]const u8 = @extern([*c]const u8, .{ + .name = "e_loclist", +}); +pub const e_re_damg: [*c]const u8 = @extern([*c]const u8, .{ + .name = "e_re_damg", +}); +pub const e_re_corr: [*c]const u8 = @extern([*c]const u8, .{ + .name = "e_re_corr", +}); +pub const e_readonly: [*c]const u8 = @extern([*c]const u8, .{ + .name = "e_readonly", +}); +pub const e_letwrong: [*c]const u8 = @extern([*c]const u8, .{ + .name = "e_letwrong", +}); +pub const e_illvar: [*c]const u8 = @extern([*c]const u8, .{ + .name = "e_illvar", +}); +pub const e_cannot_mod: [*c]const u8 = @extern([*c]const u8, .{ + .name = "e_cannot_mod", +}); +pub const e_readonlyvar: [*c]const u8 = @extern([*c]const u8, .{ + .name = "e_readonlyvar", +}); +pub const e_stringreq: [*c]const u8 = @extern([*c]const u8, .{ + .name = "e_stringreq", +}); +pub const e_dictreq: [*c]const u8 = @extern([*c]const u8, .{ + .name = "e_dictreq", +}); +pub const e_blobidx: [*c]const u8 = @extern([*c]const u8, .{ + .name = "e_blobidx", +}); +pub const e_invalblob: [*c]const u8 = @extern([*c]const u8, .{ + .name = "e_invalblob", +}); +pub const e_toomanyarg: [*c]const u8 = @extern([*c]const u8, .{ + .name = "e_toomanyarg", +}); +pub const e_toofewarg: [*c]const u8 = @extern([*c]const u8, .{ + .name = "e_toofewarg", +}); +pub const e_dictkey: [*c]const u8 = @extern([*c]const u8, .{ + .name = "e_dictkey", +}); +pub const e_listreq: [*c]const u8 = @extern([*c]const u8, .{ + .name = "e_listreq", +}); +pub const e_listblobreq: [*c]const u8 = @extern([*c]const u8, .{ + .name = "e_listblobreq", +}); +pub const e_listdictarg: [*c]const u8 = @extern([*c]const u8, .{ + .name = "e_listdictarg", +}); +pub const e_listdictblobarg: [*c]const u8 = @extern([*c]const u8, .{ + .name = "e_listdictblobarg", +}); +pub const e_readerrf: [*c]const u8 = @extern([*c]const u8, .{ + .name = "e_readerrf", +}); +pub const e_sandbox: [*c]const u8 = @extern([*c]const u8, .{ + .name = "e_sandbox", +}); +pub const e_secure: [*c]const u8 = @extern([*c]const u8, .{ + .name = "e_secure", +}); +pub const e_textlock: [*c]const u8 = @extern([*c]const u8, .{ + .name = "e_textlock", +}); +pub const e_screenmode: [*c]const u8 = @extern([*c]const u8, .{ + .name = "e_screenmode", +}); +pub const e_scroll: [*c]const u8 = @extern([*c]const u8, .{ + .name = "e_scroll", +}); +pub const e_shellempty: [*c]const u8 = @extern([*c]const u8, .{ + .name = "e_shellempty", +}); +pub const e_signdata: [*c]const u8 = @extern([*c]const u8, .{ + .name = "e_signdata", +}); +pub const e_swapclose: [*c]const u8 = @extern([*c]const u8, .{ + .name = "e_swapclose", +}); +pub const e_tagstack: [*c]const u8 = @extern([*c]const u8, .{ + .name = "e_tagstack", +}); +pub const e_toocompl: [*c]const u8 = @extern([*c]const u8, .{ + .name = "e_toocompl", +}); +pub const e_longname: [*c]const u8 = @extern([*c]const u8, .{ + .name = "e_longname", +}); +pub const e_toomsbra: [*c]const u8 = @extern([*c]const u8, .{ + .name = "e_toomsbra", +}); +pub const e_toomany: [*c]const u8 = @extern([*c]const u8, .{ + .name = "e_toomany", +}); +pub const e_trailing: [*c]const u8 = @extern([*c]const u8, .{ + .name = "e_trailing", +}); +pub const e_trailing_arg: [*c]const u8 = @extern([*c]const u8, .{ + .name = "e_trailing_arg", +}); +pub const e_umark: [*c]const u8 = @extern([*c]const u8, .{ + .name = "e_umark", +}); +pub const e_wildexpand: [*c]const u8 = @extern([*c]const u8, .{ + .name = "e_wildexpand", +}); +pub const e_winheight: [*c]const u8 = @extern([*c]const u8, .{ + .name = "e_winheight", +}); +pub const e_winwidth: [*c]const u8 = @extern([*c]const u8, .{ + .name = "e_winwidth", +}); +pub const e_write: [*c]const u8 = @extern([*c]const u8, .{ + .name = "e_write", +}); +pub const e_zerocount: [*c]const u8 = @extern([*c]const u8, .{ + .name = "e_zerocount", +}); +pub const e_usingsid: [*c]const u8 = @extern([*c]const u8, .{ + .name = "e_usingsid", +}); +pub const e_missingparen: [*c]const u8 = @extern([*c]const u8, .{ + .name = "e_missingparen", +}); +pub const e_maxmempat: [*c]const u8 = @extern([*c]const u8, .{ + .name = "e_maxmempat", +}); +pub const e_emptybuf: [*c]const u8 = @extern([*c]const u8, .{ + .name = "e_emptybuf", +}); +pub const e_nobufnr: [*c]const u8 = @extern([*c]const u8, .{ + .name = "e_nobufnr", +}); +pub const e_str_not_inside_function: [*c]const u8 = @extern([*c]const u8, .{ + .name = "e_str_not_inside_function", +}); +pub const e_invalpat: [*c]const u8 = @extern([*c]const u8, .{ + .name = "e_invalpat", +}); +pub const e_bufloaded: [*c]const u8 = @extern([*c]const u8, .{ + .name = "e_bufloaded", +}); +pub const e_notset: [*c]const u8 = @extern([*c]const u8, .{ + .name = "e_notset", +}); +pub const e_invalidreg: [*c]const u8 = @extern([*c]const u8, .{ + .name = "e_invalidreg", +}); +pub const e_dirnotf: [*c]const u8 = @extern([*c]const u8, .{ + .name = "e_dirnotf", +}); +pub const e_au_recursive: [*c]const u8 = @extern([*c]const u8, .{ + .name = "e_au_recursive", +}); +pub const e_menuothermode: [*c]const u8 = @extern([*c]const u8, .{ + .name = "e_menuothermode", +}); +pub const e_autocmd_close: [*c]const u8 = @extern([*c]const u8, .{ + .name = "e_autocmd_close", +}); +pub const e_listarg: [*c]const u8 = @extern([*c]const u8, .{ + .name = "e_listarg", +}); +pub const e_unsupportedoption: [*c]const u8 = @extern([*c]const u8, .{ + .name = "e_unsupportedoption", +}); +pub const e_fnametoolong: [*c]const u8 = @extern([*c]const u8, .{ + .name = "e_fnametoolong", +}); +pub const e_float_as_string: [*c]const u8 = @extern([*c]const u8, .{ + .name = "e_float_as_string", +}); +pub const e_inval_string: [*c]const u8 = @extern([*c]const u8, .{ + .name = "e_inval_string", +}); +pub const e_cannot_edit_other_buf: [*c]const u8 = @extern([*c]const u8, .{ + .name = "e_cannot_edit_other_buf", +}); +pub const e_not_callable_type_str: [*c]const u8 = @extern([*c]const u8, .{ + .name = "e_not_callable_type_str", +}); +pub const e_cmdmap_err: [*c]const u8 = @extern([*c]const u8, .{ + .name = "e_cmdmap_err", +}); +pub const e_cmdmap_repeated: [*c]const u8 = @extern([*c]const u8, .{ + .name = "e_cmdmap_repeated", +}); +pub const e_api_error: [*c]const u8 = @extern([*c]const u8, .{ + .name = "e_api_error", +}); +pub const e_luv_api_disabled: [*c]const u8 = @extern([*c]const u8, .{ + .name = "e_luv_api_disabled", +}); +pub const e_floatonly: [*c]const u8 = @extern([*c]const u8, .{ + .name = "e_floatonly", +}); +pub const e_floatexchange: [*c]const u8 = @extern([*c]const u8, .{ + .name = "e_floatexchange", +}); +pub const e_cannot_define_autocommands_for_all_events: [*c]const u8 = @extern([*c]const u8, .{ + .name = "e_cannot_define_autocommands_for_all_events", +}); +pub const e_resulting_text_too_long: [*c]const u8 = @extern([*c]const u8, .{ + .name = "e_resulting_text_too_long", +}); +pub const e_line_number_out_of_range: [*c]const u8 = @extern([*c]const u8, .{ + .name = "e_line_number_out_of_range", +}); +pub const e_highlight_group_name_invalid_char: [*c]const u8 = @extern([*c]const u8, .{ + .name = "e_highlight_group_name_invalid_char", +}); +pub const e_highlight_group_name_too_long: [*c]const u8 = @extern([*c]const u8, .{ + .name = "e_highlight_group_name_too_long", +}); +pub const e_invalid_line_number_nr: [*c]const u8 = @extern([*c]const u8, .{ + .name = "e_invalid_line_number_nr", +}); +pub const e_stray_closing_curly_str: [*c]u8 = @extern([*c]u8, .{ + .name = "e_stray_closing_curly_str", +}); +pub const e_missing_close_curly_str: [*c]u8 = @extern([*c]u8, .{ + .name = "e_missing_close_curly_str", +}); +pub const e_undobang_cannot_redo_or_move_branch: [*c]const u8 = @extern([*c]const u8, .{ + .name = "e_undobang_cannot_redo_or_move_branch", +}); +pub const e_trustfile: [*c]const u8 = @extern([*c]const u8, .{ + .name = "e_trustfile", +}); +pub const top_bot_msg: [*c]const u8 = @extern([*c]const u8, .{ + .name = "top_bot_msg", +}); +pub const bot_top_msg: [*c]const u8 = @extern([*c]const u8, .{ + .name = "bot_top_msg", +}); +pub const line_msg: [*c]const u8 = @extern([*c]const u8, .{ + .name = "line_msg", +}); +pub extern var time_fd: [*c]FILE; +pub extern var vim_ignored: c_int; +pub extern var embedded_mode: bool; +pub extern var headless_mode: bool; +pub const kUnknown: c_int = 0; +pub const kWorking: c_int = 1; +pub const kBroken: c_int = 2; +pub const WorkingStatus = c_uint; +pub const kCdScopeInvalid: c_int = -1; +pub const kCdScopeWindow: c_int = 0; +pub const kCdScopeTabpage: c_int = 1; +pub const kCdScopeGlobal: c_int = 2; +pub const CdScope = c_int; +pub const kCdCauseOther: c_int = -1; +pub const kCdCauseManual: c_int = 0; +pub const kCdCauseWindow: c_int = 1; +pub const kCdCauseAuto: c_int = 2; +pub const CdCause = c_int; +pub extern var windowsVersion: [20]u8; +pub extern var magic_overruled: optmagic_T; +pub extern var skip_win_fix_cursor: bool; +pub extern var skip_win_fix_scroll: bool; +pub extern var skip_update_topline: bool; +pub const struct_ui_t = extern struct { + rgb: bool, + override: bool, + composed: bool, + ui_ext: [10]bool, + width: c_int, + height: c_int, + pum_nlines: c_int, + pum_pos: bool, + pum_row: f64, + pum_col: f64, + pum_height: f64, + pum_width: f64, + term_name: [*c]u8, + term_background: [*c]u8, + term_colors: c_int, + stdin_tty: bool, + stdout_tty: bool, + data: [1]UIData, +}; +pub const kUICmdline: c_int = 0; +pub const kUIPopupmenu: c_int = 1; +pub const kUITabline: c_int = 2; +pub const kUIWildmenu: c_int = 3; +pub const kUIMessages: c_int = 4; +pub const kUILinegrid: c_int = 5; +pub const kUIMultigrid: c_int = 6; +pub const kUIHlState: c_int = 7; +pub const kUITermColors: c_int = 8; +pub const kUIFloatDebug: c_int = 9; +pub const kUIExtCount: c_int = 10; +pub const UIExtension = c_uint; +pub const ui_ext_names: [*c][*c]const u8 = @extern([*c][*c]const u8, .{ + .name = "ui_ext_names", +}); +pub const UI = struct_ui_t; +pub const kLineFlagWrap: c_int = 1; +pub const kLineFlagInvalid: c_int = 2; +const enum_unnamed_123 = c_uint; +pub const LineFlags = c_int; +pub const UIData = extern struct { + channel_id: u64, + buf: [4096]u8, + buf_wptr: [*c]u8, + cur_event: [*c]const u8, + call_buf: Array, + pack_totlen: usize, + buf_overflow: bool, + temp_buf: [*c]u8, + nevents_pos: [*c]u8, + ncalls_pos: [*c]u8, + nevents: u32, + ncalls: u32, + flushed_events: bool, + ncells_pending: usize, + hl_id: c_int, + cursor_row: Integer, + cursor_col: Integer, + client_row: Integer, + client_col: Integer, + wildmenu_active: bool, +}; +pub const struct_ui_event_callback = extern struct { + cb: LuaRef, + ext_widgets: [5]bool, +}; +pub const UIEventCallback = struct_ui_event_callback; +pub extern fn ui_init() void; +pub extern fn ui_rgb_attached() bool; +pub extern fn ui_gui_attached() bool; +pub extern fn ui_override() bool; +pub extern fn ui_active() bool; +pub extern fn ui_refresh() void; +pub extern fn ui_pum_get_height() c_int; +pub extern fn ui_pum_get_pos(pwidth: [*c]f64, pheight: [*c]f64, prow: [*c]f64, pcol: [*c]f64) bool; +pub extern fn ui_schedule_refresh() void; +pub extern fn ui_default_colors_set() void; +pub extern fn ui_busy_start() void; +pub extern fn ui_busy_stop() void; +pub extern fn vim_beep(val: c_uint) void; +pub extern fn ui_attach_impl(ui: [*c]UI, chanid: u64) void; +pub extern fn ui_detach_impl(ui: [*c]UI, chanid: u64) void; +pub extern fn ui_set_ext_option(ui: [*c]UI, ext: UIExtension, active: bool) void; +pub extern fn ui_line(grid: [*c]ScreenGrid, row: c_int, startcol: c_int, endcol: c_int, clearcol: c_int, clearattr: c_int, wrap: bool) void; +pub extern fn ui_cursor_goto(new_row: c_int, new_col: c_int) void; +pub extern fn ui_grid_cursor_goto(grid_handle: handle_T, new_row: c_int, new_col: c_int) void; +pub extern fn ui_check_cursor_grid(grid_handle: handle_T) void; +pub extern fn ui_mode_info_set() void; +pub extern fn ui_current_row() c_int; +pub extern fn ui_current_col() c_int; +pub extern fn ui_flush() void; +pub extern fn ui_check_mouse() void; +pub extern fn ui_cursor_shape() void; +pub extern fn ui_has(ext: UIExtension) bool; +pub extern fn ui_array() Array; +pub extern fn ui_grid_resize(grid_handle: handle_T, width: c_int, height: c_int, err: [*c]Error) void; +pub extern fn ui_call_event(name: [*c]u8, args: Array) void; +pub extern fn ui_cb_update_ext() void; +pub extern fn free_ui_event_callback(event_cb: [*c]UIEventCallback) void; +pub extern fn ui_add_cb(ns_id: u32, cb: LuaRef, ext_widgets: [*c]bool) void; +pub extern fn ui_remove_cb(ns_id: u32) void; +pub extern fn ui_call_mode_info_set(enabled: Boolean, cursor_styles: Array) void; +pub extern fn ui_call_update_menu() void; +pub extern fn ui_call_busy_start() void; +pub extern fn ui_call_busy_stop() void; +pub extern fn ui_call_mouse_on() void; +pub extern fn ui_call_mouse_off() void; +pub extern fn ui_call_mode_change(mode: String, mode_idx: Integer) void; +pub extern fn ui_call_bell() void; +pub extern fn ui_call_visual_bell() void; +pub extern fn ui_call_flush() void; +pub extern fn ui_call_suspend() void; +pub extern fn ui_call_set_title(title: String) void; +pub extern fn ui_call_set_icon(icon: String) void; +pub extern fn ui_call_screenshot(path: String) void; +pub extern fn ui_call_option_set(name: String, value: Object) void; +pub extern fn ui_call_stop() void; +pub extern fn ui_call_update_fg(fg: Integer) void; +pub extern fn ui_call_update_bg(bg: Integer) void; +pub extern fn ui_call_update_sp(sp: Integer) void; +pub extern fn ui_call_resize(width: Integer, height: Integer) void; +pub extern fn ui_call_clear() void; +pub extern fn ui_call_eol_clear() void; +pub extern fn ui_call_cursor_goto(row: Integer, col: Integer) void; +pub extern fn ui_call_put(str: String) void; +pub extern fn ui_call_set_scroll_region(top: Integer, bot: Integer, left: Integer, right: Integer) void; +pub extern fn ui_call_scroll(count: Integer) void; +pub extern fn ui_call_default_colors_set(rgb_fg: Integer, rgb_bg: Integer, rgb_sp: Integer, cterm_fg: Integer, cterm_bg: Integer) void; +pub extern fn ui_call_hl_attr_define(id: Integer, rgb_attrs: HlAttrs, cterm_attrs: HlAttrs, info: Array) void; +pub extern fn ui_call_hl_group_set(name: String, id: Integer) void; +pub extern fn ui_call_grid_resize(grid: Integer, width: Integer, height: Integer) void; +pub extern fn ui_composed_call_grid_resize(grid: Integer, width: Integer, height: Integer) void; +pub extern fn ui_call_grid_clear(grid: Integer) void; +pub extern fn ui_call_grid_cursor_goto(grid: Integer, row: Integer, col: Integer) void; +pub extern fn ui_composed_call_grid_cursor_goto(grid: Integer, row: Integer, col: Integer) void; +pub extern fn ui_call_grid_line(grid: Integer, row: Integer, col_start: Integer, data: Array) void; +pub extern fn ui_call_grid_scroll(grid: Integer, top: Integer, bot: Integer, left: Integer, right: Integer, rows: Integer, cols: Integer) void; +pub extern fn ui_composed_call_grid_scroll(grid: Integer, top: Integer, bot: Integer, left: Integer, right: Integer, rows: Integer, cols: Integer) void; +pub extern fn ui_call_grid_destroy(grid: Integer) void; +pub extern fn ui_call_raw_line(grid: Integer, row: Integer, startcol: Integer, endcol: Integer, clearcol: Integer, clearattr: Integer, flags: LineFlags, chunk: [*c]const schar_T, attrs: [*c]const sattr_T) void; +pub extern fn ui_composed_call_raw_line(grid: Integer, row: Integer, startcol: Integer, endcol: Integer, clearcol: Integer, clearattr: Integer, flags: LineFlags, chunk: [*c]const schar_T, attrs: [*c]const sattr_T) void; +pub extern fn ui_call_win_pos(grid: Integer, win: Window, startrow: Integer, startcol: Integer, width: Integer, height: Integer) void; +pub extern fn ui_call_win_float_pos(grid: Integer, win: Window, anchor: String, anchor_grid: Integer, anchor_row: Float, anchor_col: Float, focusable: Boolean, zindex: Integer) void; +pub extern fn ui_call_win_external_pos(grid: Integer, win: Window) void; +pub extern fn ui_call_win_hide(grid: Integer) void; +pub extern fn ui_call_win_close(grid: Integer) void; +pub extern fn ui_call_msg_set_pos(grid: Integer, row: Integer, scrolled: Boolean, sep_char: String) void; +pub extern fn ui_composed_call_msg_set_pos(grid: Integer, row: Integer, scrolled: Boolean, sep_char: String) void; +pub extern fn ui_call_win_viewport(grid: Integer, win: Window, topline: Integer, botline: Integer, curline: Integer, curcol: Integer, line_count: Integer, scroll_delta: Integer) void; +pub extern fn ui_call_win_extmark(grid: Integer, win: Window, ns_id: Integer, mark_id: Integer, row: Integer, col: Integer) void; +pub extern fn ui_call_popupmenu_show(items: Array, selected: Integer, row: Integer, col: Integer, grid: Integer) void; +pub extern fn ui_call_popupmenu_hide() void; +pub extern fn ui_call_popupmenu_select(selected: Integer) void; +pub extern fn ui_call_tabline_update(current: Tabpage, tabs: Array, current_buffer: Buffer, buffers: Array) void; +pub extern fn ui_call_cmdline_show(content: Array, pos: Integer, firstc: String, prompt: String, indent: Integer, level: Integer) void; +pub extern fn ui_call_cmdline_pos(pos: Integer, level: Integer) void; +pub extern fn ui_call_cmdline_special_char(c: String, shift: Boolean, level: Integer) void; +pub extern fn ui_call_cmdline_hide(level: Integer) void; +pub extern fn ui_call_cmdline_block_show(lines: Array) void; +pub extern fn ui_call_cmdline_block_append(lines: Array) void; +pub extern fn ui_call_cmdline_block_hide() void; +pub extern fn ui_call_wildmenu_show(items: Array) void; +pub extern fn ui_call_wildmenu_select(selected: Integer) void; +pub extern fn ui_call_wildmenu_hide() void; +pub extern fn ui_call_msg_show(kind: String, content: Array, replace_last: Boolean) void; +pub extern fn ui_call_msg_clear() void; +pub extern fn ui_call_msg_showcmd(content: Array) void; +pub extern fn ui_call_msg_showmode(content: Array) void; +pub extern fn ui_call_msg_ruler(content: Array) void; +pub extern fn ui_call_msg_history_show(entries: Array) void; +pub extern fn ui_call_msg_history_clear() void; +pub extern var resize_events: ?*MultiQueue; +pub extern fn remote_ui_disconnect(channel_id: u64) void; +pub extern fn remote_ui_wait_for_attach() void; +pub extern fn nvim_ui_attach(channel_id: u64, width: Integer, height: Integer, options: Dictionary, err: [*c]Error) void; +pub extern fn ui_attach(channel_id: u64, width: Integer, height: Integer, enable_rgb: Boolean, err: [*c]Error) void; +pub extern fn nvim_ui_set_focus(channel_id: u64, gained: Boolean, @"error": [*c]Error) void; +pub extern fn nvim_ui_detach(channel_id: u64, err: [*c]Error) void; +pub extern fn remote_ui_stop(ui: [*c]UI) void; +pub extern fn nvim_ui_try_resize(channel_id: u64, width: Integer, height: Integer, err: [*c]Error) void; +pub extern fn nvim_ui_set_option(channel_id: u64, name: String, value: Object, @"error": [*c]Error) void; +pub extern fn nvim_ui_try_resize_grid(channel_id: u64, grid: Integer, width: Integer, height: Integer, err: [*c]Error) void; +pub extern fn nvim_ui_pum_set_height(channel_id: u64, height: Integer, err: [*c]Error) void; +pub extern fn nvim_ui_pum_set_bounds(channel_id: u64, width: Float, height: Float, row: Float, col: Float, err: [*c]Error) void; +pub extern fn remote_ui_grid_clear(ui: [*c]UI, grid: Integer) void; +pub extern fn remote_ui_grid_resize(ui: [*c]UI, grid: Integer, width: Integer, height: Integer) void; +pub extern fn remote_ui_grid_scroll(ui: [*c]UI, grid: Integer, top: Integer, bot: Integer, left: Integer, right: Integer, rows: Integer, cols: Integer) void; +pub extern fn remote_ui_default_colors_set(ui: [*c]UI, rgb_fg: Integer, rgb_bg: Integer, rgb_sp: Integer, cterm_fg: Integer, cterm_bg: Integer) void; +pub extern fn remote_ui_hl_attr_define(ui: [*c]UI, id: Integer, rgb_attrs: HlAttrs, cterm_attrs: HlAttrs, info: Array) void; +pub extern fn remote_ui_highlight_set(ui: [*c]UI, id: c_int) void; +pub extern fn remote_ui_grid_cursor_goto(ui: [*c]UI, grid: Integer, row: Integer, col: Integer) void; +pub extern fn remote_ui_cursor_goto(ui: [*c]UI, row: Integer, col: Integer) void; +pub extern fn remote_ui_put(ui: [*c]UI, cell: [*c]const u8) void; +pub extern fn remote_ui_raw_line(ui: [*c]UI, grid: Integer, row: Integer, startcol: Integer, endcol: Integer, clearcol: Integer, clearattr: Integer, flags: LineFlags, chunk: [*c]const schar_T, attrs: [*c]const sattr_T) void; +pub extern fn remote_ui_flush_buf(ui: [*c]UI) void; +pub extern fn remote_ui_flush(ui: [*c]UI) void; +pub extern fn remote_ui_event(ui: [*c]UI, name: [*c]u8, args: Array) void; +pub extern fn remote_ui_inspect(ui: [*c]UI, info: [*c]Dictionary) void; +pub extern fn remote_ui_mode_info_set(ui: [*c]UI, enabled: Boolean, cursor_styles: Array) void; +pub extern fn remote_ui_update_menu(ui: [*c]UI) void; +pub extern fn remote_ui_busy_start(ui: [*c]UI) void; +pub extern fn remote_ui_busy_stop(ui: [*c]UI) void; +pub extern fn remote_ui_mouse_on(ui: [*c]UI) void; +pub extern fn remote_ui_mouse_off(ui: [*c]UI) void; +pub extern fn remote_ui_mode_change(ui: [*c]UI, mode: String, mode_idx: Integer) void; +pub extern fn remote_ui_bell(ui: [*c]UI) void; +pub extern fn remote_ui_visual_bell(ui: [*c]UI) void; +pub extern fn remote_ui_suspend(ui: [*c]UI) void; +pub extern fn remote_ui_set_title(ui: [*c]UI, title: String) void; +pub extern fn remote_ui_set_icon(ui: [*c]UI, icon: String) void; +pub extern fn remote_ui_screenshot(ui: [*c]UI, path: String) void; +pub extern fn remote_ui_option_set(ui: [*c]UI, name: String, value: Object) void; +pub extern fn remote_ui_hl_group_set(ui: [*c]UI, name: String, id: Integer) void; +pub extern fn remote_ui_msg_set_pos(ui: [*c]UI, grid: Integer, row: Integer, scrolled: Boolean, sep_char: String) void; +pub extern fn remote_ui_win_viewport(ui: [*c]UI, grid: Integer, win: Window, topline: Integer, botline: Integer, curline: Integer, curcol: Integer, line_count: Integer, scroll_delta: Integer) void; +pub extern fn nvim_get_hl_id_by_name(name: String) Integer; +pub extern fn nvim_get_hl(ns_id: Integer, opts: [*c]KeyDict_get_highlight, arena: [*c]Arena, err: [*c]Error) Dictionary; +pub extern fn nvim_set_hl(ns_id: Integer, name: String, val: [*c]KeyDict_highlight, err: [*c]Error) void; +pub extern fn nvim_set_hl_ns(ns_id: Integer, err: [*c]Error) void; +pub extern fn nvim_set_hl_ns_fast(ns_id: Integer, err: [*c]Error) void; +pub extern fn nvim_feedkeys(keys: String, mode: String, escape_ks: Boolean) void; +pub extern fn nvim_input(keys: String) Integer; +pub extern fn nvim_input_mouse(button: String, action: String, modifier: String, grid: Integer, row: Integer, col: Integer, err: [*c]Error) void; +pub extern fn nvim_replace_termcodes(str: String, from_part: Boolean, do_lt: Boolean, special: Boolean) String; +pub extern fn nvim_exec_lua(code: String, args: Array, err: [*c]Error) Object; +pub extern fn nvim_notify(msg: String, log_level: Integer, opts: Dictionary, err: [*c]Error) Object; +pub extern fn nvim_strwidth(text: String, err: [*c]Error) Integer; +pub extern fn nvim_list_runtime_paths(err: [*c]Error) Array; +pub extern fn nvim__runtime_inspect() Array; +pub extern fn nvim_get_runtime_file(name: String, all: Boolean, err: [*c]Error) Array; +pub extern fn nvim__get_lib_dir() String; +pub extern fn nvim__get_runtime(pat: Array, all: Boolean, opts: [*c]KeyDict_runtime, err: [*c]Error) Array; +pub extern fn nvim_set_current_dir(dir: String, err: [*c]Error) void; +pub extern fn nvim_get_current_line(err: [*c]Error) String; +pub extern fn nvim_set_current_line(line: String, err: [*c]Error) void; +pub extern fn nvim_del_current_line(err: [*c]Error) void; +pub extern fn nvim_get_var(name: String, err: [*c]Error) Object; +pub extern fn nvim_set_var(name: String, value: Object, err: [*c]Error) void; +pub extern fn nvim_del_var(name: String, err: [*c]Error) void; +pub extern fn nvim_get_vvar(name: String, err: [*c]Error) Object; +pub extern fn nvim_set_vvar(name: String, value: Object, err: [*c]Error) void; +pub extern fn nvim_echo(chunks: Array, history: Boolean, opts: [*c]KeyDict_echo_opts, err: [*c]Error) void; +pub extern fn nvim_out_write(str: String) void; +pub extern fn nvim_err_write(str: String) void; +pub extern fn nvim_err_writeln(str: String) void; +pub extern fn nvim_list_bufs() Array; +pub extern fn nvim_get_current_buf() Buffer; +pub extern fn nvim_set_current_buf(buffer: Buffer, err: [*c]Error) void; +pub extern fn nvim_list_wins() Array; +pub extern fn nvim_get_current_win() Window; +pub extern fn nvim_set_current_win(window: Window, err: [*c]Error) void; +pub extern fn nvim_create_buf(listed: Boolean, scratch: Boolean, err: [*c]Error) Buffer; +pub extern fn nvim_open_term(buffer: Buffer, opts: Dictionary, err: [*c]Error) Integer; +pub extern fn nvim_chan_send(chan: Integer, data: String, err: [*c]Error) void; +pub extern fn nvim_list_tabpages() Array; +pub extern fn nvim_get_current_tabpage() Tabpage; +pub extern fn nvim_set_current_tabpage(tabpage: Tabpage, err: [*c]Error) void; +pub extern fn nvim_paste(data: String, crlf: Boolean, phase: Integer, err: [*c]Error) Boolean; +pub extern fn nvim_put(lines: Array, @"type": String, after: Boolean, follow: Boolean, err: [*c]Error) void; +pub extern fn nvim_subscribe(channel_id: u64, event: String) void; +pub extern fn nvim_unsubscribe(channel_id: u64, event: String) void; +pub extern fn nvim_get_color_by_name(name: String) Integer; +pub extern fn nvim_get_color_map() Dictionary; +pub extern fn nvim_get_context(opts: [*c]KeyDict_context, err: [*c]Error) Dictionary; +pub extern fn nvim_load_context(dict: Dictionary) Object; +pub extern fn nvim_get_mode() Dictionary; +pub extern fn nvim_get_keymap(mode: String) Array; +pub extern fn nvim_set_keymap(channel_id: u64, mode: String, lhs: String, rhs: String, opts: [*c]KeyDict_keymap, err: [*c]Error) void; +pub extern fn nvim_del_keymap(channel_id: u64, mode: String, lhs: String, err: [*c]Error) void; +pub extern fn nvim_get_api_info(channel_id: u64, arena: [*c]Arena) Array; +pub extern fn nvim_set_client_info(channel_id: u64, name: String, version: Dictionary, @"type": String, methods: Dictionary, attributes: Dictionary, err: [*c]Error) void; +pub extern fn nvim_get_chan_info(chan: Integer, err: [*c]Error) Dictionary; +pub extern fn nvim_list_chans() Array; +pub extern fn nvim_call_atomic(channel_id: u64, calls: Array, arena: [*c]Arena, err: [*c]Error) Array; +pub extern fn nvim__id(obj: Object) Object; +pub extern fn nvim__id_array(arr: Array) Array; +pub extern fn nvim__id_dictionary(dct: Dictionary) Dictionary; +pub extern fn nvim__id_float(flt: Float) Float; +pub extern fn nvim__stats() Dictionary; +pub extern fn nvim_list_uis() Array; +pub extern fn nvim_get_proc_children(pid: Integer, err: [*c]Error) Array; +pub extern fn nvim_get_proc(pid: Integer, err: [*c]Error) Object; +pub extern fn nvim_select_popupmenu_item(item: Integer, insert: Boolean, finish: Boolean, opts: Dictionary, err: [*c]Error) void; +pub extern fn nvim__inspect_cell(grid: Integer, row: Integer, col: Integer, arena: [*c]Arena, err: [*c]Error) Array; +pub extern fn nvim__screenshot(path: String) void; +pub extern fn nvim__unpack(str: String, err: [*c]Error) Object; +pub extern fn nvim_del_mark(name: String, err: [*c]Error) Boolean; +pub extern fn nvim_get_mark(name: String, opts: Dictionary, err: [*c]Error) Array; +pub extern fn nvim_eval_statusline(str: String, opts: [*c]KeyDict_eval_statusline, err: [*c]Error) Dictionary; +pub extern fn nvim_error_event(channel_id: u64, lvl: Integer, data: String) void; +pub extern fn nvim_exec2(channel_id: u64, src: String, opts: [*c]KeyDict_exec_opts, err: [*c]Error) Dictionary; +pub extern fn exec_impl(channel_id: u64, src: String, opts: [*c]KeyDict_exec_opts, err: [*c]Error) String; +pub extern fn nvim_command(command: String, err: [*c]Error) void; +pub extern fn nvim_eval(expr: String, err: [*c]Error) Object; +pub extern fn nvim_call_function(@"fn": String, args: Array, err: [*c]Error) Object; +pub extern fn nvim_call_dict_function(dict: Object, @"fn": String, args: Array, err: [*c]Error) Object; +pub extern fn nvim_parse_expression(expr: String, flags: String, highlight: Boolean, err: [*c]Error) Dictionary; +pub extern fn nvim_open_win(buffer: Buffer, enter: Boolean, config: [*c]KeyDict_float_config, err: [*c]Error) Window; +pub extern fn nvim_win_set_config(window: Window, config: [*c]KeyDict_float_config, err: [*c]Error) void; +pub extern fn nvim_win_get_config(window: Window, err: [*c]Error) Dictionary; +pub extern fn nvim_win_get_buf(window: Window, err: [*c]Error) Buffer; +pub extern fn nvim_win_set_buf(window: Window, buffer: Buffer, err: [*c]Error) void; +pub extern fn nvim_win_get_cursor(window: Window, err: [*c]Error) Array; +pub extern fn nvim_win_set_cursor(window: Window, pos: Array, err: [*c]Error) void; +pub extern fn nvim_win_get_height(window: Window, err: [*c]Error) Integer; +pub extern fn nvim_win_set_height(window: Window, height: Integer, err: [*c]Error) void; +pub extern fn nvim_win_get_width(window: Window, err: [*c]Error) Integer; +pub extern fn nvim_win_set_width(window: Window, width: Integer, err: [*c]Error) void; +pub extern fn nvim_win_get_var(window: Window, name: String, err: [*c]Error) Object; +pub extern fn nvim_win_set_var(window: Window, name: String, value: Object, err: [*c]Error) void; +pub extern fn nvim_win_del_var(window: Window, name: String, err: [*c]Error) void; +pub extern fn nvim_win_get_position(window: Window, err: [*c]Error) Array; +pub extern fn nvim_win_get_tabpage(window: Window, err: [*c]Error) Tabpage; +pub extern fn nvim_win_get_number(window: Window, err: [*c]Error) Integer; +pub extern fn nvim_win_is_valid(window: Window) Boolean; +pub extern fn nvim_win_hide(window: Window, err: [*c]Error) void; +pub extern fn nvim_win_close(window: Window, force: Boolean, err: [*c]Error) void; +pub extern fn nvim_win_call(window: Window, fun: LuaRef, err: [*c]Error) Object; +pub extern fn nvim_win_set_hl_ns(window: Window, ns_id: Integer, err: [*c]Error) void; +pub extern fn arabic_maycombine(two: c_int) bool; +pub extern fn arabic_combine(one: c_int, two: c_int) bool; +pub extern fn arabic_shape(c: c_int, ccp: [*c]c_int, c1p: [*c]c_int, prev_c: c_int, prev_c1: c_int, next_c: c_int) c_int; +pub extern fn alist_clear(al: [*c]alist_T) void; +pub extern fn alist_init(al: [*c]alist_T) void; +pub extern fn alist_unlink(al: [*c]alist_T) void; +pub extern fn alist_new() void; +pub extern fn alist_set(al: [*c]alist_T, count: c_int, files: [*c][*c]u8, use_curbuf: c_int, fnum_list: [*c]c_int, fnum_len: c_int) void; +pub extern fn alist_add(al: [*c]alist_T, fname: [*c]u8, set_fnum: c_int) void; +pub extern fn get_arglist_exp(str: [*c]u8, fcountp: [*c]c_int, fnamesp: [*c][*c][*c]u8, wig: bool) c_int; +pub extern fn set_arglist(str: [*c]u8) void; +pub extern fn editing_arg_idx(win: [*c]win_T) bool; +pub extern fn check_arg_idx(win: [*c]win_T) void; +pub extern fn ex_args(eap: [*c]exarg_T) void; +pub extern fn ex_previous(eap: [*c]exarg_T) void; +pub extern fn ex_rewind(eap: [*c]exarg_T) void; +pub extern fn ex_last(eap: [*c]exarg_T) void; +pub extern fn ex_argument(eap: [*c]exarg_T) void; +pub extern fn do_argfile(eap: [*c]exarg_T, argn: c_int) void; +pub extern fn ex_next(eap: [*c]exarg_T) void; +pub extern fn ex_argdedupe(eap: [*c]exarg_T) void; +pub extern fn ex_argedit(eap: [*c]exarg_T) void; +pub extern fn ex_argadd(eap: [*c]exarg_T) void; +pub extern fn ex_argdelete(eap: [*c]exarg_T) void; +pub extern fn get_arglist_name(xp: [*c]expand_T, idx: c_int) [*c]u8; +pub extern fn alist_name(aep: [*c]aentry_T) [*c]u8; +pub extern fn ex_all(eap: [*c]exarg_T) void; +pub extern fn arg_all() [*c]u8; +pub extern fn f_argc(argvars: [*c]typval_T, rettv: [*c]typval_T, fptr: EvalFuncData) void; +pub extern fn f_argidx(argvars: [*c]typval_T, rettv: [*c]typval_T, fptr: EvalFuncData) void; +pub extern fn f_arglistid(argvars: [*c]typval_T, rettv: [*c]typval_T, fptr: EvalFuncData) void; +pub extern fn f_argv(argvars: [*c]typval_T, rettv: [*c]typval_T, fptr: EvalFuncData) void; +pub extern fn ml_open(buf: [*c]buf_T) c_int; +pub extern fn ml_setname(buf: [*c]buf_T) void; +pub extern fn ml_open_files() void; +pub extern fn ml_open_file(buf: [*c]buf_T) void; +pub extern fn check_need_swap(newfile: bool) void; +pub extern fn ml_close(buf: [*c]buf_T, del_file: c_int) void; +pub extern fn ml_close_all(del_file: bool) void; +pub extern fn ml_close_notmod() void; +pub extern fn ml_timestamp(buf: [*c]buf_T) void; +pub extern fn ml_recover(checkext: bool) void; +pub extern fn recover_names(fname: [*c]u8, do_list: bool, ret_list: [*c]list_T, nr: c_int, fname_out: [*c][*c]u8) c_int; +pub extern fn make_percent_swname(dir: [*c]const u8, name: [*c]const u8) [*c]u8; +pub extern fn get_b0_dict(fname: [*c]const u8, d: [*c]dict_T) void; +pub extern fn ml_sync_all(check_file: c_int, check_char: c_int, do_fsync: bool) void; +pub extern fn ml_preserve(buf: [*c]buf_T, message: c_int, do_fsync: bool) void; +pub extern fn ml_get(lnum: linenr_T) [*c]u8; +pub extern fn ml_get_pos(pos: [*c]const pos_T) [*c]u8; +pub extern fn gchar_pos(pos: [*c]pos_T) c_int; +pub extern fn ml_get_buf(buf: [*c]buf_T, lnum: linenr_T, will_change: bool) [*c]u8; +pub extern fn ml_line_alloced() c_int; +pub extern fn ml_append(lnum: linenr_T, line: [*c]u8, len: colnr_T, newfile: bool) c_int; +pub extern fn ml_append_buf(buf: [*c]buf_T, lnum: linenr_T, line: [*c]u8, len: colnr_T, newfile: bool) c_int; +pub extern fn ml_add_deleted_len(ptr: [*c]u8, len: isize) void; +pub extern fn ml_add_deleted_len_buf(buf: [*c]buf_T, ptr: [*c]u8, len: isize) void; +pub extern fn ml_replace(lnum: linenr_T, line: [*c]u8, copy: bool) c_int; +pub extern fn ml_replace_buf(buf: [*c]buf_T, lnum: linenr_T, line: [*c]u8, copy: bool) c_int; +pub extern fn ml_delete(lnum: linenr_T, message: bool) c_int; +pub extern fn ml_setmarked(lnum: linenr_T) void; +pub extern fn ml_firstmarked() linenr_T; +pub extern fn ml_clearmarked() void; +pub extern fn ml_flush_deleted_bytes(buf: [*c]buf_T, codepoints: [*c]usize, codeunits: [*c]usize) usize; +pub extern fn resolve_symlink(fname: [*c]const u8, buf: [*c]u8) c_int; +pub extern fn makeswapname(fname: [*c]u8, ffname: [*c]u8, buf: [*c]buf_T, dir_name: [*c]u8) [*c]u8; +pub extern fn get_file_in_dir(fname: [*c]u8, dname: [*c]u8) [*c]u8; +pub extern fn ml_setflags(buf: [*c]buf_T) void; +pub extern fn ml_find_line_or_offset(buf: [*c]buf_T, lnum: linenr_T, offp: [*c]c_long, no_ff: bool) c_long; +pub extern fn goto_byte(cnt: c_long) void; +pub extern fn inc(lp: [*c]pos_T) c_int; +pub extern fn incl(lp: [*c]pos_T) c_int; +pub extern fn dec(lp: [*c]pos_T) c_int; +pub extern fn decl(lp: [*c]pos_T) c_int; +pub const GETF_SETMARK: c_int = 1; +pub const GETF_ALT: c_int = 2; +pub const GETF_SWITCH: c_int = 4; +pub const enum_getf_values = c_uint; +pub const GETFILE_ERROR: c_int = 1; +pub const GETFILE_NOT_WRITTEN: c_int = 2; +pub const GETFILE_SAME_FILE: c_int = 0; +pub const GETFILE_OPEN_OTHER: c_int = -1; +pub const GETFILE_UNUSED: c_int = 8; +pub const enum_getf_retvalues = c_int; +pub const BLN_CURBUF: c_int = 1; +pub const BLN_LISTED: c_int = 2; +pub const BLN_DUMMY: c_int = 4; +pub const BLN_NEW: c_int = 8; +pub const BLN_NOOPT: c_int = 16; +pub const BLN_NOCURWIN: c_int = 128; +pub const enum_bln_values = c_uint; +pub const DOBUF_GOTO: c_int = 0; +pub const DOBUF_SPLIT: c_int = 1; +pub const DOBUF_UNLOAD: c_int = 2; +pub const DOBUF_DEL: c_int = 3; +pub const DOBUF_WIPE: c_int = 4; +pub const enum_dobuf_action_values = c_uint; +pub const DOBUF_CURRENT: c_int = 0; +pub const DOBUF_FIRST: c_int = 1; +pub const DOBUF_LAST: c_int = 2; +pub const DOBUF_MOD: c_int = 3; +pub const enum_dobuf_start_values = c_uint; +pub const BFA_DEL: c_int = 1; +pub const BFA_WIPE: c_int = 2; +pub const BFA_KEEP_UNDO: c_int = 4; +pub const BFA_IGNORE_ABORT: c_int = 8; +pub const enum_bfa_values = c_uint; +pub extern var msg_loclist: [*c]u8; +pub extern var msg_qflist: [*c]u8; +pub extern fn get_highest_fnum() c_int; +pub extern fn buffer_ensure_loaded(buf: [*c]buf_T) void; +pub extern fn open_buffer(read_stdin: c_int, eap: [*c]exarg_T, flags_arg: c_int) c_int; +pub extern fn set_bufref(bufref: [*c]bufref_T, buf: [*c]buf_T) void; +pub extern fn bufref_valid(bufref: [*c]bufref_T) bool; +pub extern fn buf_valid(buf: [*c]buf_T) bool; +pub extern fn close_buffer(win: [*c]win_T, buf: [*c]buf_T, action: c_int, abort_if_last: bool, ignore_abort: bool) bool; +pub extern fn buf_clear_file(buf: [*c]buf_T) void; +pub extern fn buf_clear() void; +pub extern fn buf_freeall(buf: [*c]buf_T, flags: c_int) void; +pub extern fn goto_buffer(eap: [*c]exarg_T, start: c_int, dir: c_int, count: c_int) void; +pub extern fn handle_swap_exists(old_curbuf: [*c]bufref_T) void; +pub extern fn do_bufdel(command: c_int, arg: [*c]u8, addr_count: c_int, start_bnr: c_int, end_bnr: c_int, forceit: c_int) [*c]u8; +pub extern fn do_buffer(action: c_int, start: c_int, dir: c_int, count: c_int, forceit: c_int) c_int; +pub extern fn set_curbuf(buf: [*c]buf_T, action: c_int) void; +pub extern fn enter_buffer(buf: [*c]buf_T) void; +pub extern fn do_autochdir() void; +pub extern fn no_write_message() void; +pub extern fn no_write_message_nobang(buf: [*c]const buf_T) void; +pub extern fn buflist_new(ffname_arg: [*c]u8, sfname_arg: [*c]u8, lnum: linenr_T, flags: c_int) [*c]buf_T; +pub extern fn curbuf_reusable() bool; +pub extern fn free_buf_options(buf: [*c]buf_T, free_p_ff: c_int) void; +pub extern fn buflist_getfile(n: c_int, lnum: linenr_T, options: c_int, forceit: c_int) c_int; +pub extern fn buflist_getfpos() void; +pub extern fn buflist_findname_exp(fname: [*c]u8) [*c]buf_T; +pub extern fn buflist_findname(ffname: [*c]u8) [*c]buf_T; +pub extern fn buflist_findpat(pattern: [*c]const u8, pattern_end: [*c]const u8, unlisted: bool, diffmode: bool, curtab_only: bool) c_int; +pub extern fn ExpandBufnames(pat: [*c]u8, num_file: [*c]c_int, file: [*c][*c][*c]u8, options: c_int) c_int; +pub extern fn buflist_findnr(nr: c_int) [*c]buf_T; +pub extern fn buflist_nr2name(n: c_int, fullname: c_int, helptail: c_int) [*c]u8; +pub extern fn buflist_setfpos(buf: [*c]buf_T, win: [*c]win_T, lnum: linenr_T, col: colnr_T, copy_options: bool) void; +pub extern fn get_winopts(buf: [*c]buf_T) void; +pub extern fn buflist_findfmark(buf: [*c]buf_T) [*c]fmark_T; +pub extern fn buflist_findlnum(buf: [*c]buf_T) linenr_T; +pub extern fn buflist_list(eap: [*c]exarg_T) void; +pub extern fn buflist_name_nr(fnum: c_int, fname: [*c][*c]u8, lnum: [*c]linenr_T) c_int; +pub extern fn setfname(buf: [*c]buf_T, ffname_arg: [*c]u8, sfname_arg: [*c]u8, message: bool) c_int; +pub extern fn buf_set_name(fnum: c_int, name: [*c]u8) void; +pub extern fn buf_name_changed(buf: [*c]buf_T) void; +pub extern fn setaltfname(ffname: [*c]u8, sfname: [*c]u8, lnum: linenr_T) [*c]buf_T; +pub extern fn getaltfname(errmsg: bool) [*c]u8; +pub extern fn buflist_add(fname: [*c]u8, flags: c_int) c_int; +pub extern fn buflist_altfpos(win: [*c]win_T) void; +pub extern fn otherfile(ffname: [*c]u8) bool; +pub extern fn buf_set_file_id(buf: [*c]buf_T) void; +pub extern fn fileinfo(fullname: c_int, shorthelp: c_int, dont_truncate: c_int) void; +pub extern fn col_print(buf: [*c]u8, buflen: usize, col: c_int, vcol: c_int) void; +pub extern fn maketitle() void; +pub extern fn resettitle() void; +pub extern fn get_rel_pos(wp: [*c]win_T, buf: [*c]u8, buflen: c_int) void; +pub extern fn append_arg_number(wp: [*c]win_T, buf: [*c]u8, buflen: c_int, add_file: bool) bool; +pub extern fn fname_expand(buf: [*c]buf_T, ffname: [*c][*c]u8, sfname: [*c][*c]u8) void; +pub extern fn bt_prompt(buf: [*c]buf_T) bool; +pub extern fn ex_buffer_all(eap: [*c]exarg_T) void; +pub extern fn do_modelines(flags: c_int) void; +pub extern fn bt_help(buf: [*c]const buf_T) bool; +pub extern fn bt_normal(buf: [*c]const buf_T) bool; +pub extern fn bt_quickfix(buf: [*c]const buf_T) bool; +pub extern fn bt_terminal(buf: [*c]const buf_T) bool; +pub extern fn bt_nofilename(buf: [*c]const buf_T) bool; +pub extern fn bt_nofile(buf: [*c]const buf_T) bool; +pub extern fn bt_dontwrite(buf: [*c]const buf_T) bool; +pub extern fn bt_dontwrite_msg(buf: [*c]const buf_T) bool; +pub extern fn buf_hide(buf: [*c]const buf_T) bool; +pub extern fn buf_spname(buf: [*c]buf_T) [*c]u8; +pub extern fn buf_signcols_del_check(buf: [*c]buf_T, line1: linenr_T, line2: linenr_T) void; +pub extern fn buf_signcols_add_check(buf: [*c]buf_T, added: [*c]sign_entry_T) void; +pub extern fn buf_signcols(buf: [*c]buf_T, maximum: c_int) c_int; +pub extern fn buf_get_fname(buf: [*c]const buf_T) [*c]u8; +pub extern fn set_buflisted(on: c_int) void; +pub extern fn buf_contents_changed(buf: [*c]buf_T) bool; +pub extern fn wipe_buffer(buf: [*c]buf_T, aucmd: bool) void; +pub extern fn buf_open_scratch(bufnr: handle_T, bufname: [*c]u8) c_int; +pub inline fn buf_set_changedtick(buf: [*c]buf_T, changedtick: varnumber_T) void { + var old_val: typval_T = buf.*.changedtick_di.di_tv; + const changedtick_di: [*c]dictitem_T = tv_dict_find(buf.*.b_vars, "changedtick", @bitCast(ptrdiff_t, @sizeOf([12]u8) -% @bitCast(c_ulong, @as(c_long, @as(c_int, 1))))); + _ = blk: { + _ = @sizeOf(c_int); + break :blk blk_1: { + break :blk_1 if (changedtick_di != @ptrCast([*c]dictitem_T, @alignCast(@import("std").meta.alignment([*c]dictitem_T), @intToPtr(?*anyopaque, @as(c_int, 0))))) {} else { + __assert_fail("changedtick_di != NULL", "./_nvim/src/nvim/buffer.h", @bitCast(c_uint, @as(c_int, 92)), "void buf_set_changedtick(buf_T *const, const varnumber_T)"); + }; + }; + }; + _ = blk: { + _ = @sizeOf(c_int); + break :blk blk_1: { + break :blk_1 if (changedtick_di.*.di_tv.v_type == @bitCast(c_uint, VAR_NUMBER)) {} else { + __assert_fail("changedtick_di->di_tv.v_type == VAR_NUMBER", "./_nvim/src/nvim/buffer.h", @bitCast(c_uint, @as(c_int, 93)), "void buf_set_changedtick(buf_T *const, const varnumber_T)"); + }; + }; + }; + _ = blk: { + _ = @sizeOf(c_int); + break :blk blk_1: { + break :blk_1 if (changedtick_di.*.di_tv.v_lock == @bitCast(c_uint, VAR_FIXED)) {} else { + __assert_fail("changedtick_di->di_tv.v_lock == VAR_FIXED", "./_nvim/src/nvim/buffer.h", @bitCast(c_uint, @as(c_int, 94)), "void buf_set_changedtick(buf_T *const, const varnumber_T)"); + }; + }; + }; + _ = blk: { + _ = @sizeOf(c_int); + break :blk blk_1: { + break :blk_1 if (@bitCast(c_int, @as(c_uint, changedtick_di.*.di_flags)) == (DI_FLAGS_RO | DI_FLAGS_FIX)) {} else { + __assert_fail("changedtick_di->di_flags == (DI_FLAGS_RO|DI_FLAGS_FIX)", "./_nvim/src/nvim/buffer.h", @bitCast(c_uint, @as(c_int, 97)), "void buf_set_changedtick(buf_T *const, const varnumber_T)"); + }; + }; + }; + _ = blk: { + _ = @sizeOf(c_int); + break :blk blk_1: { + break :blk_1 if (changedtick_di == @ptrCast([*c]dictitem_T, @alignCast(@import("std").meta.alignment([*c]dictitem_T), &buf.*.changedtick_di))) {} else { + __assert_fail("changedtick_di == (dictitem_T *)&buf->changedtick_di", "./_nvim/src/nvim/buffer.h", @bitCast(c_uint, @as(c_int, 99)), "void buf_set_changedtick(buf_T *const, const varnumber_T)"); + }; + }; + }; + buf.*.changedtick_di.di_tv.vval.v_number = changedtick; + if (tv_dict_is_watched(buf.*.b_vars)) { + tv_dict_watcher_notify(buf.*.b_vars, @ptrCast([*c]u8, @alignCast(@import("std").meta.alignment([*c]u8), &buf.*.changedtick_di.di_key)), &buf.*.changedtick_di.di_tv, &old_val); + } +} +pub inline fn buf_get_changedtick(buf: [*c]const buf_T) varnumber_T { + return buf.*.changedtick_di.di_tv.vval.v_number; +} +pub inline fn buf_inc_changedtick(buf: [*c]buf_T) void { + buf_set_changedtick(buf, buf_get_changedtick(buf) + @bitCast(varnumber_T, @as(c_long, @as(c_int, 1)))); +} +pub fn buf_is_empty(arg_buf: [*c]buf_T) callconv(.C) bool { + var buf = arg_buf; + return (buf.*.b_ml.ml_line_count == @as(c_int, 1)) and (@bitCast(c_int, @as(c_uint, ml_get_buf(buf, @bitCast(linenr_T, @as(c_int, 1)), @as(c_int, 0) != 0).*)) == @as(c_int, '\x00')); +} +pub extern var extmark_splice_pending: c_int; +pub const ExtmarkInfo = extern struct { + ns_id: u64, + mark_id: u64, + row: c_int, + col: colnr_T, + end_row: c_int, + end_col: colnr_T, + right_gravity: bool, + end_right_gravity: bool, + decor: Decoration, +}; +pub const ExtmarkInfoArray = extern struct { + size: usize, + capacity: usize, + items: [*c]ExtmarkInfo, +}; +pub const bcount_t = ptrdiff_t; +pub const ExtmarkSplice = extern struct { + start_row: c_int, + start_col: colnr_T, + old_row: c_int, + old_col: colnr_T, + new_row: c_int, + new_col: colnr_T, + start_byte: bcount_t, + old_byte: bcount_t, + new_byte: bcount_t, +}; +pub const ExtmarkMove = extern struct { + start_row: c_int, + start_col: c_int, + extent_row: c_int, + extent_col: c_int, + new_row: c_int, + new_col: c_int, + start_byte: bcount_t, + extent_byte: bcount_t, + new_byte: bcount_t, +}; +pub const ExtmarkSavePos = extern struct { + mark: u64, + old_row: c_int, + old_col: colnr_T, + row: c_int, + col: colnr_T, +}; +pub const kExtmarkSplice: c_int = 0; +pub const kExtmarkMove: c_int = 1; +pub const kExtmarkUpdate: c_int = 2; +pub const kExtmarkSavePos: c_int = 3; +pub const kExtmarkClear: c_int = 4; +pub const UndoObjectType = c_uint; +pub const kExtmarkNone: c_int = 1; +pub const kExtmarkSign: c_int = 2; +pub const kExtmarkVirtText: c_int = 4; +pub const kExtmarkVirtLines: c_int = 8; +pub const kExtmarkHighlight: c_int = 16; +pub const ExtmarkType = c_uint; +pub extern fn extmark_set(buf: [*c]buf_T, ns_id: u32, idp: [*c]u32, row: c_int, col: colnr_T, end_row: c_int, end_col: colnr_T, decor: [*c]Decoration, right_gravity: bool, end_right_gravity: bool, op: ExtmarkOp) void; +pub extern fn extmark_del(buf: [*c]buf_T, ns_id: u32, id: u32) bool; +pub extern fn extmark_clear(buf: [*c]buf_T, ns_id: u32, l_row: c_int, l_col: colnr_T, u_row: c_int, u_col: colnr_T) bool; +pub extern fn extmark_get(buf: [*c]buf_T, ns_id: u32, l_row: c_int, l_col: colnr_T, u_row: c_int, u_col: colnr_T, amount: i64, reverse: bool, all_ns: bool, type_filter: ExtmarkType) ExtmarkInfoArray; +pub extern fn extmark_from_id(buf: [*c]buf_T, ns_id: u32, id: u32) ExtmarkInfo; +pub extern fn extmark_free_all(buf: [*c]buf_T) void; +pub extern fn u_extmark_copy(buf: [*c]buf_T, l_row: c_int, l_col: colnr_T, u_row: c_int, u_col: colnr_T) void; +pub extern fn extmark_apply_undo(undo_info: ExtmarkUndoObject, undo: bool) void; +pub extern fn extmark_adjust(buf: [*c]buf_T, line1: linenr_T, line2: linenr_T, amount: linenr_T, amount_after: linenr_T, undo: ExtmarkOp) void; +pub extern fn extmark_splice(buf: [*c]buf_T, start_row: c_int, start_col: colnr_T, old_row: c_int, old_col: colnr_T, old_byte: bcount_t, new_row: c_int, new_col: colnr_T, new_byte: bcount_t, undo: ExtmarkOp) void; +pub extern fn extmark_splice_impl(buf: [*c]buf_T, start_row: c_int, start_col: colnr_T, start_byte: bcount_t, old_row: c_int, old_col: colnr_T, old_byte: bcount_t, new_row: c_int, new_col: colnr_T, new_byte: bcount_t, undo: ExtmarkOp) void; +pub extern fn extmark_splice_cols(buf: [*c]buf_T, start_row: c_int, start_col: colnr_T, old_col: colnr_T, new_col: colnr_T, undo: ExtmarkOp) void; +pub extern fn extmark_move_region(buf: [*c]buf_T, start_row: c_int, start_col: colnr_T, start_byte: bcount_t, extent_row: c_int, extent_col: colnr_T, extent_byte: bcount_t, new_row: c_int, new_col: colnr_T, new_byte: bcount_t, undo: ExtmarkOp) void; +pub extern fn buf_updates_register(buf: [*c]buf_T, channel_id: u64, cb: BufUpdateCallbacks, send_buffer: bool) bool; +pub extern fn buf_updates_active(buf: [*c]buf_T) bool; +pub extern fn buf_updates_send_end(buf: [*c]buf_T, channelid: u64) void; +pub extern fn buf_updates_unregister(buf: [*c]buf_T, channelid: u64) void; +pub extern fn buf_free_callbacks(buf: [*c]buf_T) void; +pub extern fn buf_updates_unload(buf: [*c]buf_T, can_reload: bool) void; +pub extern fn buf_updates_send_changes(buf: [*c]buf_T, firstline: linenr_T, num_added: i64, num_removed: i64) void; +pub extern fn buf_updates_send_splice(buf: [*c]buf_T, start_row: c_int, start_col: colnr_T, start_byte: bcount_t, old_row: c_int, old_col: colnr_T, old_byte: bcount_t, new_row: c_int, new_col: colnr_T, new_byte: bcount_t) void; +pub extern fn buf_updates_changedtick(buf: [*c]buf_T) void; +pub extern fn buf_updates_changedtick_single(buf: [*c]buf_T, channel_id: u64) void; +pub extern fn buffer_update_callbacks_free(cb: BufUpdateCallbacks) void; +pub extern fn buf_write(buf: [*c]buf_T, fname: [*c]u8, sfname: [*c]u8, start: linenr_T, end: linenr_T, eap: [*c]exarg_T, append: c_int, forceit: c_int, reset_changed: c_int, filtering: c_int) c_int; +pub extern fn change_warning(buf: [*c]buf_T, col: c_int) void; +pub extern fn changed() void; +pub extern fn changed_internal() void; +pub extern fn changed_bytes(lnum: linenr_T, col: colnr_T) void; +pub extern fn inserted_bytes(lnum: linenr_T, start_col: colnr_T, old_col: c_int, new_col: c_int) void; +pub extern fn appended_lines(lnum: linenr_T, count: linenr_T) void; +pub extern fn appended_lines_mark(lnum: linenr_T, count: c_long) void; +pub extern fn deleted_lines(lnum: linenr_T, count: linenr_T) void; +pub extern fn deleted_lines_mark(lnum: linenr_T, count: c_long) void; +pub extern fn changed_lines_buf(buf: [*c]buf_T, lnum: linenr_T, lnume: linenr_T, xtra: linenr_T) void; +pub extern fn changed_lines(lnum: linenr_T, col: colnr_T, lnume: linenr_T, xtra: linenr_T, do_buf_event: bool) void; +pub extern fn unchanged(buf: [*c]buf_T, ff: c_int, always_inc_changedtick: bool) void; +pub extern fn save_file_ff(buf: [*c]buf_T) void; +pub extern fn file_ff_differs(buf: [*c]buf_T, ignore_empty: bool) bool; +pub extern fn ins_bytes(p: [*c]u8) void; +pub extern fn ins_bytes_len(p: [*c]u8, len: usize) void; +pub extern fn ins_char(c: c_int) void; +pub extern fn ins_char_bytes(buf: [*c]u8, charlen: usize) void; +pub extern fn ins_str(s: [*c]u8) void; +pub extern fn del_char(fixpos: bool) c_int; +pub extern fn del_chars(count: c_long, fixpos: c_int) c_int; +pub extern fn del_bytes(count: colnr_T, fixpos_arg: bool, use_delcombine: bool) c_int; +pub extern fn copy_indent(size: c_int, src: [*c]u8) c_int; +pub extern fn open_line(dir: c_int, flags: c_int, second_line_indent: c_int, did_do_comment: [*c]bool) c_int; +pub extern fn truncate_line(fixpos: c_int) void; +pub extern fn del_lines(nlines: c_long, undo: bool) void; +pub extern fn get_leader_len(line: [*c]u8, flags: [*c][*c]u8, backward: bool, include_space: bool) c_int; +pub extern fn get_last_leader_offset(line: [*c]u8, flags: [*c][*c]u8) c_int; +pub const RBuffer = struct_rbuffer; +pub const rbuffer_callback = ?*const fn ([*c]RBuffer, ?*anyopaque) callconv(.C) void; +pub const struct_rbuffer = extern struct { + full_cb: rbuffer_callback align(8), + nonfull_cb: rbuffer_callback, + data: ?*anyopaque, + size: usize, + temp: [*c]u8, + end_ptr: [*c]u8, + read_ptr: [*c]u8, + write_ptr: [*c]u8, + pub fn start_ptr(self: anytype) @import("std").zig.c_translation.FlexibleArrayType(@TypeOf(self), u8) { + const Intermediate = @import("std").zig.c_translation.FlexibleArrayType(@TypeOf(self), u8); + const ReturnType = @import("std").zig.c_translation.FlexibleArrayType(@TypeOf(self), u8); + return @ptrCast(ReturnType, @alignCast(@alignOf(u8), @ptrCast(Intermediate, self) + 64)); + } +}; +pub extern fn rbuffer_new(capacity: usize) [*c]RBuffer; +pub extern fn rbuffer_free(buf: [*c]RBuffer) void; +pub extern fn rbuffer_size(buf: [*c]RBuffer) usize; +pub extern fn rbuffer_capacity(buf: [*c]RBuffer) usize; +pub extern fn rbuffer_space(buf: [*c]RBuffer) usize; +pub extern fn rbuffer_write_ptr(buf: [*c]RBuffer, write_count: [*c]usize) [*c]u8; +pub extern fn rbuffer_reset(buf: [*c]RBuffer) void; +pub extern fn rbuffer_produced(buf: [*c]RBuffer, count: usize) void; +pub extern fn rbuffer_read_ptr(buf: [*c]RBuffer, read_count: [*c]usize) [*c]u8; +pub extern fn rbuffer_consumed(buf: [*c]RBuffer, count: usize) void; +pub extern fn rbuffer_consumed_compact(buf: [*c]RBuffer, count: usize) void; +pub extern fn rbuffer_write(buf: [*c]RBuffer, src: [*c]const u8, src_size: usize) usize; +pub extern fn rbuffer_read(buf: [*c]RBuffer, dst: [*c]u8, dst_size: usize) usize; +pub extern fn rbuffer_get(buf: [*c]RBuffer, index: usize) [*c]u8; +pub extern fn rbuffer_cmp(buf: [*c]RBuffer, str: [*c]const u8, count: usize) c_int; +const union_unnamed_124 = extern union { + pipe: uv_pipe_t, + tcp: uv_tcp_t, + idle: uv_idle_t, +}; +pub const Stream = struct_stream; +pub const stream_read_cb = ?*const fn ([*c]Stream, [*c]RBuffer, usize, ?*anyopaque, bool) callconv(.C) void; +pub const stream_write_cb = ?*const fn ([*c]Stream, ?*anyopaque, c_int) callconv(.C) void; +pub const stream_close_cb = ?*const fn ([*c]Stream, ?*anyopaque) callconv(.C) void; +pub const struct_stream = extern struct { + closed: bool, + did_eof: bool, + uv: union_unnamed_124, + uvstream: [*c]uv_stream_t, + uvbuf: uv_buf_t, + buffer: [*c]RBuffer, + fd: uv_file, + read_cb: stream_read_cb, + write_cb: stream_write_cb, + cb_data: ?*anyopaque, + close_cb: stream_close_cb, + internal_close_cb: stream_close_cb, + close_cb_data: ?*anyopaque, + internal_data: ?*anyopaque, + fpos: usize, + curmem: usize, + maxmem: usize, + pending_reqs: usize, + num_bytes: usize, + events: ?*MultiQueue, +}; +pub extern fn stream_set_blocking(fd: c_int, blocking: bool) c_int; +pub extern fn stream_init(loop: [*c]Loop, stream: [*c]Stream, fd: c_int, uvstream: [*c]uv_stream_t) void; +pub extern fn stream_close(stream: [*c]Stream, on_stream_close: stream_close_cb, data: ?*anyopaque) void; +pub extern fn stream_may_close(stream: [*c]Stream) void; +pub extern fn stream_close_handle(stream: [*c]Stream) void; +pub extern fn rstream_init_fd(loop: [*c]Loop, stream: [*c]Stream, fd: c_int, bufsize: usize) void; +pub extern fn rstream_init_stream(stream: [*c]Stream, uvstream: [*c]uv_stream_t, bufsize: usize) void; +pub extern fn rstream_init(stream: [*c]Stream, bufsize: usize) void; +pub extern fn rstream_start(stream: [*c]Stream, cb: stream_read_cb, data: ?*anyopaque) void; +pub extern fn rstream_stop(stream: [*c]Stream) void; +pub const wbuffer_data_finalizer = ?*const fn (?*anyopaque) callconv(.C) void; +pub const struct_wbuffer = extern struct { + size: usize, + refcount: usize, + data: [*c]u8, + cb: wbuffer_data_finalizer, +}; +pub const WBuffer = struct_wbuffer; +pub extern fn wstream_init_fd(loop: [*c]Loop, stream: [*c]Stream, fd: c_int, maxmem: usize) void; +pub extern fn wstream_init_stream(stream: [*c]Stream, uvstream: [*c]uv_stream_t, maxmem: usize) void; +pub extern fn wstream_init(stream: [*c]Stream, maxmem: usize) void; +pub extern fn wstream_set_write_cb(stream: [*c]Stream, cb: stream_write_cb, data: ?*anyopaque) void; +pub extern fn wstream_write(stream: [*c]Stream, buffer: [*c]WBuffer) bool; +pub extern fn wstream_new_buffer(data: [*c]u8, size: usize, refcount: usize, cb: wbuffer_data_finalizer) [*c]WBuffer; +pub extern fn wstream_release_wbuffer(buffer: [*c]WBuffer) void; +pub const Process = struct_process; +pub const process_exit_cb = ?*const fn ([*c]Process, c_int, ?*anyopaque) callconv(.C) void; +pub const internal_process_cb = ?*const fn ([*c]Process) callconv(.C) void; +pub const struct_process = extern struct { + type: ProcessType, + loop: [*c]Loop, + data: ?*anyopaque, + pid: c_int, + status: c_int, + refcount: c_int, + exit_signal: u8, + stopped_time: u64, + cwd: [*c]const u8, + argv: [*c][*c]u8, + env: [*c]dict_T, + in: Stream, + out: Stream, + err: Stream, + cb: process_exit_cb, + internal_exit_cb: internal_process_cb, + internal_close_cb: internal_process_cb, + closed: bool, + detach: bool, + overlapped: bool, + fwd_err: bool, + events: ?*MultiQueue, +}; +pub const kProcessTypeUv: c_int = 0; +pub const kProcessTypePty: c_int = 1; +pub const ProcessType = c_uint; +pub fn process_init(arg_loop_1: [*c]Loop, arg_type: ProcessType, arg_data: ?*anyopaque) callconv(.C) Process { + var loop_1 = arg_loop_1; + var @"type" = arg_type; + var data = arg_data; + return Process{ + .type = @"type", + .loop = loop_1, + .data = data, + .pid = @as(c_int, 0), + .status = -@as(c_int, 1), + .refcount = @as(c_int, 0), + .exit_signal = @import("std").mem.zeroes(u8), + .stopped_time = @bitCast(u64, @as(c_long, @as(c_int, 0))), + .cwd = null, + .argv = null, + .env = null, + .in = Stream{ + .closed = @as(c_int, 0) != 0, + .did_eof = false, + .uv = @import("std").mem.zeroes(union_unnamed_124), + .uvstream = null, + .uvbuf = @import("std").mem.zeroes(uv_buf_t), + .buffer = null, + .fd = @import("std").mem.zeroes(uv_file), + .read_cb = @import("std").mem.zeroes(stream_read_cb), + .write_cb = @import("std").mem.zeroes(stream_write_cb), + .cb_data = null, + .close_cb = @import("std").mem.zeroes(stream_close_cb), + .internal_close_cb = @import("std").mem.zeroes(stream_close_cb), + .close_cb_data = null, + .internal_data = null, + .fpos = @import("std").mem.zeroes(usize), + .curmem = @import("std").mem.zeroes(usize), + .maxmem = @import("std").mem.zeroes(usize), + .pending_reqs = @import("std").mem.zeroes(usize), + .num_bytes = @import("std").mem.zeroes(usize), + .events = null, + }, + .out = Stream{ + .closed = @as(c_int, 0) != 0, + .did_eof = false, + .uv = @import("std").mem.zeroes(union_unnamed_124), + .uvstream = null, + .uvbuf = @import("std").mem.zeroes(uv_buf_t), + .buffer = null, + .fd = @import("std").mem.zeroes(uv_file), + .read_cb = @import("std").mem.zeroes(stream_read_cb), + .write_cb = @import("std").mem.zeroes(stream_write_cb), + .cb_data = null, + .close_cb = @import("std").mem.zeroes(stream_close_cb), + .internal_close_cb = @import("std").mem.zeroes(stream_close_cb), + .close_cb_data = null, + .internal_data = null, + .fpos = @import("std").mem.zeroes(usize), + .curmem = @import("std").mem.zeroes(usize), + .maxmem = @import("std").mem.zeroes(usize), + .pending_reqs = @import("std").mem.zeroes(usize), + .num_bytes = @import("std").mem.zeroes(usize), + .events = null, + }, + .err = Stream{ + .closed = @as(c_int, 0) != 0, + .did_eof = false, + .uv = @import("std").mem.zeroes(union_unnamed_124), + .uvstream = null, + .uvbuf = @import("std").mem.zeroes(uv_buf_t), + .buffer = null, + .fd = @import("std").mem.zeroes(uv_file), + .read_cb = @import("std").mem.zeroes(stream_read_cb), + .write_cb = @import("std").mem.zeroes(stream_write_cb), + .cb_data = null, + .close_cb = @import("std").mem.zeroes(stream_close_cb), + .internal_close_cb = @import("std").mem.zeroes(stream_close_cb), + .close_cb_data = null, + .internal_data = null, + .fpos = @import("std").mem.zeroes(usize), + .curmem = @import("std").mem.zeroes(usize), + .maxmem = @import("std").mem.zeroes(usize), + .pending_reqs = @import("std").mem.zeroes(usize), + .num_bytes = @import("std").mem.zeroes(usize), + .events = null, + }, + .cb = null, + .internal_exit_cb = null, + .internal_close_cb = null, + .closed = @as(c_int, 0) != 0, + .detach = @as(c_int, 0) != 0, + .overlapped = false, + .fwd_err = @as(c_int, 0) != 0, + .events = null, + }; +} +pub fn process_is_stopped(arg_proc: [*c]Process) callconv(.C) bool { + var proc = arg_proc; + var exited: bool = proc.*.status >= @as(c_int, 0); + return (@as(c_int, @boolToInt(exited)) != 0) or (proc.*.stopped_time != @bitCast(u64, @as(c_long, @as(c_int, 0)))); +} +pub extern fn process_spawn(proc: [*c]Process, in: bool, out: bool, err: bool) c_int; +pub extern fn process_teardown(loop: [*c]Loop) void; +pub extern fn process_close_streams(proc: [*c]Process) void; +pub extern fn process_wait(proc: [*c]Process, ms: c_int, events: ?*MultiQueue) c_int; +pub extern fn process_stop(proc: [*c]Process) void; +pub extern fn process_free(proc: [*c]Process) void; +pub extern fn exit_from_channel(status: c_int) void; +pub const struct_libuv_process = extern struct { + process: Process, + uv: uv_process_t, + uvopts: uv_process_options_t, + uvstdio: [4]uv_stdio_container_t, +}; +pub const LibuvProcess = struct_libuv_process; +pub fn libuv_process_init(arg_loop_1: [*c]Loop, arg_data: ?*anyopaque) callconv(.C) LibuvProcess { + var loop_1 = arg_loop_1; + var data = arg_data; + var rv: LibuvProcess = LibuvProcess{ + .process = process_init(loop_1, @bitCast(c_uint, kProcessTypeUv), data), + .uv = @import("std").mem.zeroes(uv_process_t), + .uvopts = @import("std").mem.zeroes(uv_process_options_t), + .uvstdio = @import("std").mem.zeroes([4]uv_stdio_container_t), + }; + return rv; +} +pub extern fn libuv_process_spawn(uvproc: [*c]LibuvProcess) c_int; +pub extern fn libuv_process_close(uvproc: [*c]LibuvProcess) void; +const struct_unnamed_126 = extern struct { + handle: uv_tcp_t, + addrinfo: [*c]struct_addrinfo, +}; +const struct_unnamed_127 = extern struct { + handle: uv_pipe_t, +}; +const union_unnamed_125 = extern union { + tcp: struct_unnamed_126, + pipe: struct_unnamed_127, +}; +pub const SocketWatcher = struct_socket_watcher; +pub const socket_cb = ?*const fn ([*c]SocketWatcher, c_int, ?*anyopaque) callconv(.C) void; +pub const socket_close_cb = ?*const fn ([*c]SocketWatcher, ?*anyopaque) callconv(.C) void; +pub const struct_socket_watcher = extern struct { + addr: [256]u8, + uv: union_unnamed_125, + stream: [*c]uv_stream_t, + data: ?*anyopaque, + cb: socket_cb, + close_cb: socket_close_cb, + events: ?*MultiQueue, +}; +pub extern fn socket_watcher_init(loop: [*c]Loop, watcher: [*c]SocketWatcher, endpoint: [*c]const u8) c_int; +pub extern fn socket_watcher_start(watcher: [*c]SocketWatcher, backlog: c_int, cb: socket_cb) c_int; +pub extern fn socket_watcher_accept(watcher: [*c]SocketWatcher, stream: [*c]Stream) c_int; +pub extern fn socket_watcher_close(watcher: [*c]SocketWatcher, cb: socket_close_cb) void; +pub extern fn socket_connect(loop: [*c]Loop, stream: [*c]Stream, is_tcp: bool, address: [*c]const u8, timeout: c_int, @"error": [*c][*c]const u8) bool; +pub extern var main_loop: Loop; +pub const mparm_T = extern struct { + argc: c_int, + argv: [*c][*c]u8, + use_vimrc: [*c]u8, + clean: bool, + n_commands: c_int, + commands: [10][*c]u8, + cmds_tofree: [10]u8, + n_pre_commands: c_int, + pre_commands: [10][*c]u8, + luaf: [*c]u8, + lua_arg0: c_int, + edit_type: c_int, + tagname: [*c]u8, + use_ef: [*c]u8, + input_istext: bool, + no_swap_file: c_int, + use_debug_break_level: c_int, + window_count: c_int, + window_layout: c_int, + diff_mode: c_int, + listen_addr: [*c]u8, + remote: c_int, + server_addr: [*c]u8, + scriptin: [*c]u8, + scriptout: [*c]u8, + scriptout_append: bool, + had_stdin_file: bool, +}; +pub extern fn event_init() void; +pub extern fn event_teardown() bool; +pub extern fn early_init(paramp: [*c]mparm_T) void; +pub extern fn main(argc: c_int, argv: [*c][*c]u8) c_int; +pub extern fn os_exit(r: c_int) noreturn; +pub extern fn getout(exitval: c_int) noreturn; +pub extern fn preserve_exit(errmsg: [*c]const u8) noreturn; +pub const _msgpack_atomic_counter_t = c_uint; +pub const struct_msgpack_zone_finalizer = extern struct { + func: ?*const fn (?*anyopaque) callconv(.C) void, + data: ?*anyopaque, +}; +pub const msgpack_zone_finalizer = struct_msgpack_zone_finalizer; +pub const struct_msgpack_zone_finalizer_array = extern struct { + tail: [*c]msgpack_zone_finalizer, + end: [*c]msgpack_zone_finalizer, + array: [*c]msgpack_zone_finalizer, +}; +pub const msgpack_zone_finalizer_array = struct_msgpack_zone_finalizer_array; +pub const struct_msgpack_zone_chunk = opaque {}; +pub const msgpack_zone_chunk = struct_msgpack_zone_chunk; +pub const struct_msgpack_zone_chunk_list = extern struct { + free: usize, + ptr: [*c]u8, + head: ?*msgpack_zone_chunk, +}; +pub const msgpack_zone_chunk_list = struct_msgpack_zone_chunk_list; +pub const struct_msgpack_zone = extern struct { + chunk_list: msgpack_zone_chunk_list, + finalizer_array: msgpack_zone_finalizer_array, + chunk_size: usize, +}; +pub const msgpack_zone = struct_msgpack_zone; +pub extern fn msgpack_zone_init(zone: [*c]msgpack_zone, chunk_size: usize) bool; +pub extern fn msgpack_zone_destroy(zone: [*c]msgpack_zone) void; +pub extern fn msgpack_zone_new(chunk_size: usize) [*c]msgpack_zone; +pub extern fn msgpack_zone_free(zone: [*c]msgpack_zone) void; +pub fn msgpack_zone_malloc(arg_zone: [*c]msgpack_zone, arg_size: usize) callconv(.C) ?*anyopaque { + var zone = arg_zone; + var size = arg_size; + var aligned: [*c]u8 = @intToPtr([*c]u8, @intCast(usize, @ptrToInt(zone.*.chunk_list.ptr + (@sizeOf(?*anyopaque) -% @bitCast(c_ulong, @as(c_long, @as(c_int, 1)))))) & ~@bitCast(usize, @sizeOf(?*anyopaque) -% @bitCast(c_ulong, @as(c_long, @as(c_int, 1))))); + var adjusted_size: usize = size +% @bitCast(usize, @divExact(@bitCast(c_long, @ptrToInt(aligned) -% @ptrToInt(zone.*.chunk_list.ptr)), @sizeOf(u8))); + if (zone.*.chunk_list.free >= adjusted_size) { + zone.*.chunk_list.free -%= adjusted_size; + zone.*.chunk_list.ptr += adjusted_size; + return @ptrCast(?*anyopaque, aligned); + } + { + var ptr: ?*anyopaque = msgpack_zone_malloc_expand(zone, size +% (@sizeOf(?*anyopaque) -% @bitCast(c_ulong, @as(c_long, @as(c_int, 1))))); + if (ptr != null) { + return @ptrCast(?*anyopaque, @intToPtr([*c]u8, @intCast(usize, @ptrToInt(ptr)) & ~@bitCast(usize, @sizeOf(?*anyopaque) -% @bitCast(c_ulong, @as(c_long, @as(c_int, 1)))))); + } + } + return @intToPtr(?*anyopaque, @as(c_int, 0)); +} +pub fn msgpack_zone_malloc_no_align(arg_zone: [*c]msgpack_zone, arg_size: usize) callconv(.C) ?*anyopaque { + var zone = arg_zone; + var size = arg_size; + var ptr: [*c]u8 = undefined; + var cl: [*c]msgpack_zone_chunk_list = &zone.*.chunk_list; + if (zone.*.chunk_list.free < size) { + return msgpack_zone_malloc_expand(zone, size); + } + ptr = cl.*.ptr; + cl.*.free -%= size; + cl.*.ptr += size; + return @ptrCast(?*anyopaque, ptr); +} +pub fn msgpack_zone_push_finalizer(arg_zone: [*c]msgpack_zone, arg_func: ?*const fn (?*anyopaque) callconv(.C) void, arg_data: ?*anyopaque) callconv(.C) bool { + var zone = arg_zone; + var func = arg_func; + var data = arg_data; + const fa: [*c]msgpack_zone_finalizer_array = &zone.*.finalizer_array; + var fin: [*c]msgpack_zone_finalizer = fa.*.tail; + if (fin == fa.*.end) { + return msgpack_zone_push_finalizer_expand(zone, func, data); + } + fin.*.func = func; + fin.*.data = data; + fa.*.tail += 1; + return @as(c_int, 1) != 0; +} +pub fn msgpack_zone_swap(arg_a: [*c]msgpack_zone, arg_b: [*c]msgpack_zone) callconv(.C) void { + var a = arg_a; + var b = arg_b; + var tmp: msgpack_zone = a.*; + a.* = b.*; + b.* = tmp; +} +pub extern fn msgpack_zone_is_empty(zone: [*c]msgpack_zone) bool; +pub extern fn msgpack_zone_clear(zone: [*c]msgpack_zone) void; +pub extern fn msgpack_zone_malloc_expand(zone: [*c]msgpack_zone, size: usize) ?*anyopaque; +pub extern fn msgpack_zone_push_finalizer_expand(zone: [*c]msgpack_zone, func: ?*const fn (?*anyopaque) callconv(.C) void, data: ?*anyopaque) bool; +pub const MSGPACK_OBJECT_NIL: c_int = 0; +pub const MSGPACK_OBJECT_BOOLEAN: c_int = 1; +pub const MSGPACK_OBJECT_POSITIVE_INTEGER: c_int = 2; +pub const MSGPACK_OBJECT_NEGATIVE_INTEGER: c_int = 3; +pub const MSGPACK_OBJECT_FLOAT32: c_int = 10; +pub const MSGPACK_OBJECT_FLOAT64: c_int = 4; +pub const MSGPACK_OBJECT_FLOAT: c_int = 4; +pub const MSGPACK_OBJECT_STR: c_int = 5; +pub const MSGPACK_OBJECT_ARRAY: c_int = 6; +pub const MSGPACK_OBJECT_MAP: c_int = 7; +pub const MSGPACK_OBJECT_BIN: c_int = 8; +pub const MSGPACK_OBJECT_EXT: c_int = 9; +pub const msgpack_object_type = c_uint; +pub const struct_msgpack_object = extern struct { + type: msgpack_object_type, + via: msgpack_object_union, +}; +pub const msgpack_object = struct_msgpack_object; +pub const struct_msgpack_object_kv = extern struct { + key: msgpack_object, + val: msgpack_object, +}; +pub const msgpack_object_array = extern struct { + size: u32, + ptr: [*c]struct_msgpack_object, +}; +pub const msgpack_object_map = extern struct { + size: u32, + ptr: [*c]struct_msgpack_object_kv, +}; +pub const msgpack_object_str = extern struct { + size: u32, + ptr: [*c]const u8, +}; +pub const msgpack_object_bin = extern struct { + size: u32, + ptr: [*c]const u8, +}; +pub const msgpack_object_ext = extern struct { + type: i8, + size: u32, + ptr: [*c]const u8, +}; +pub const msgpack_object_union = extern union { + boolean: bool, + u64: u64, + i64: i64, + f64: f64, + array: msgpack_object_array, + map: msgpack_object_map, + str: msgpack_object_str, + bin: msgpack_object_bin, + ext: msgpack_object_ext, +}; +pub const msgpack_object_kv = struct_msgpack_object_kv; +pub extern fn msgpack_object_print(out: [*c]FILE, o: msgpack_object) void; +pub extern fn msgpack_object_print_buffer(buffer: [*c]u8, buffer_size: usize, o: msgpack_object) c_int; +pub extern fn msgpack_object_equal(x: msgpack_object, y: msgpack_object) bool; +pub const struct_msgpack_timestamp = extern struct { + tv_sec: i64, + tv_nsec: u32, +}; +pub const msgpack_timestamp = struct_msgpack_timestamp; +pub fn msgpack_object_to_timestamp(arg_obj: [*c]const msgpack_object, arg_ts: [*c]msgpack_timestamp) callconv(.C) bool { + var obj = arg_obj; + var ts = arg_ts; + if (obj.*.type != @bitCast(c_uint, MSGPACK_OBJECT_EXT)) return @as(c_int, 0) != 0; + if (@bitCast(c_int, @as(c_int, obj.*.via.ext.type)) != -@as(c_int, 1)) return @as(c_int, 0) != 0; + while (true) { + switch (obj.*.via.ext.size) { + @bitCast(u32, @as(c_int, 4)) => { + ts.*.tv_nsec = 0; + { + var v: u32 = undefined; + while (true) { + _ = memcpy(@ptrCast(?*anyopaque, &v), @ptrCast(?*const anyopaque, obj.*.via.ext.ptr), @sizeOf(u32)); + (&v).* = ntohl((&v).*); + if (!false) break; + } + ts.*.tv_sec = @bitCast(i64, @as(c_ulong, v)); + } + return @as(c_int, 1) != 0; + }, + @bitCast(u32, @as(c_int, 8)) => { + { + var value: u64 = undefined; + while (true) { + _ = memcpy(@ptrCast(?*anyopaque, &value), @ptrCast(?*const anyopaque, obj.*.via.ext.ptr), @sizeOf(u64)); + (&value).* = @bitCast(u64, __bswap_64((&value).*)); + if (!false) break; + } + ts.*.tv_nsec = @bitCast(u32, @truncate(c_uint, value >> @intCast(@import("std").math.Log2Int(u64), 34))); + ts.*.tv_sec = @bitCast(i64, @truncate(c_ulong, @bitCast(c_ulonglong, @as(c_ulonglong, value)) & @bitCast(c_ulonglong, @as(c_longlong, 17179869183)))); + return @as(c_int, 1) != 0; + } + }, + @bitCast(u32, @as(c_int, 12)) => { + while (true) { + _ = memcpy(@ptrCast(?*anyopaque, &ts.*.tv_nsec), @ptrCast(?*const anyopaque, obj.*.via.ext.ptr), @sizeOf(u32)); + (&ts.*.tv_nsec).* = ntohl((&ts.*.tv_nsec).*); + if (!false) break; + } + while (true) { + _ = memcpy(@ptrCast(?*anyopaque, &ts.*.tv_sec), @ptrCast(?*const anyopaque, obj.*.via.ext.ptr + @bitCast(usize, @intCast(isize, @as(c_int, 4)))), @sizeOf(i64)); + (&ts.*.tv_sec).* = @bitCast(i64, __bswap_64(@bitCast(__uint64_t, (&ts.*.tv_sec).*))); + if (!false) break; + } + return @as(c_int, 1) != 0; + }, + else => return @as(c_int, 0) != 0, + } + break; + } + return false; +} +pub const msgpack_packer_write = ?*const fn (?*anyopaque, [*c]const u8, usize) callconv(.C) c_int; +pub const struct_msgpack_packer = extern struct { + data: ?*anyopaque, + callback: msgpack_packer_write, +}; +pub const msgpack_packer = struct_msgpack_packer; +pub fn msgpack_packer_init(arg_pk: [*c]msgpack_packer, arg_data: ?*anyopaque, arg_callback: msgpack_packer_write) callconv(.C) void { + var pk = arg_pk; + var data = arg_data; + var callback = arg_callback; + pk.*.data = data; + pk.*.callback = callback; +} +pub fn msgpack_packer_new(arg_data: ?*anyopaque, arg_callback: msgpack_packer_write) callconv(.C) [*c]msgpack_packer { + var data = arg_data; + var callback = arg_callback; + var pk: [*c]msgpack_packer = @ptrCast([*c]msgpack_packer, @alignCast(@import("std").meta.alignment([*c]msgpack_packer), calloc(@bitCast(c_ulong, @as(c_long, @as(c_int, 1))), @sizeOf(msgpack_packer)))); + if (!(pk != null)) { + return null; + } + msgpack_packer_init(pk, data, callback); + return pk; +} +pub fn msgpack_packer_free(arg_pk: [*c]msgpack_packer) callconv(.C) void { + var pk = arg_pk; + free(@ptrCast(?*anyopaque, pk)); +} +pub fn msgpack_pack_char(arg_x: [*c]msgpack_packer, arg_d: u8) callconv(.C) c_int { + var x = arg_x; + var d = arg_d; + while (true) { + if (@bitCast(c_int, @as(c_uint, d)) < -(@as(c_int, 1) << @intCast(@import("std").math.Log2Int(c_int), 5))) { + var buf: [2]u8 = [2]u8{ + 208, + @ptrCast([*c]u8, @alignCast(@import("std").meta.alignment([*c]u8), &d))[@intCast(c_uint, @as(c_int, 0))], + }; + return x.*.callback.?(x.*.data, @ptrCast([*c]const u8, @alignCast(@import("std").meta.alignment([*c]const u8), @ptrCast([*c]u8, @alignCast(@import("std").meta.alignment([*c]u8), &buf)))), @bitCast(usize, @as(c_long, @as(c_int, 2)))); + } else { + return x.*.callback.?(x.*.data, @ptrCast([*c]const u8, @alignCast(@import("std").meta.alignment([*c]const u8), &@ptrCast([*c]u8, @alignCast(@import("std").meta.alignment([*c]u8), &d))[@intCast(c_uint, @as(c_int, 0))])), @bitCast(usize, @as(c_long, @as(c_int, 1)))); + } + if (!false) break; + } + return 0; +} +pub fn msgpack_pack_signed_char(arg_x: [*c]msgpack_packer, arg_d: i8) callconv(.C) c_int { + var x = arg_x; + var d = arg_d; + while (true) { + if (@bitCast(c_int, @as(c_int, d)) < -(@as(c_int, 1) << @intCast(@import("std").math.Log2Int(c_int), 5))) { + var buf: [2]u8 = [2]u8{ + 208, + @ptrCast([*c]u8, @alignCast(@import("std").meta.alignment([*c]u8), &d))[@intCast(c_uint, @as(c_int, 0))], + }; + return x.*.callback.?(x.*.data, @ptrCast([*c]const u8, @alignCast(@import("std").meta.alignment([*c]const u8), @ptrCast([*c]u8, @alignCast(@import("std").meta.alignment([*c]u8), &buf)))), @bitCast(usize, @as(c_long, @as(c_int, 2)))); + } else { + return x.*.callback.?(x.*.data, @ptrCast([*c]const u8, @alignCast(@import("std").meta.alignment([*c]const u8), &@ptrCast([*c]u8, @alignCast(@import("std").meta.alignment([*c]u8), &d))[@intCast(c_uint, @as(c_int, 0))])), @bitCast(usize, @as(c_long, @as(c_int, 1)))); + } + if (!false) break; + } + return 0; +} +pub fn msgpack_pack_short(arg_x: [*c]msgpack_packer, arg_d: c_short) callconv(.C) c_int { + var x = arg_x; + var d = arg_d; + while (true) { + if (@bitCast(c_int, @as(c_int, d)) < -(@as(c_int, 1) << @intCast(@import("std").math.Log2Int(c_int), 5))) { + if (@bitCast(c_int, @as(c_int, d)) < -(@as(c_int, 1) << @intCast(@import("std").math.Log2Int(c_int), 7))) { + var buf: [3]u8 = undefined; + buf[@intCast(c_uint, @as(c_int, 0))] = 209; + while (true) { + var val: u16 = ntohs(@bitCast(u16, @bitCast(i16, d))); + _ = memcpy(@ptrCast(?*anyopaque, &buf[@intCast(c_uint, @as(c_int, 1))]), @ptrCast(?*const anyopaque, &val), @bitCast(c_ulong, @as(c_long, @as(c_int, 2)))); + if (!false) break; + } + return x.*.callback.?(x.*.data, @ptrCast([*c]const u8, @alignCast(@import("std").meta.alignment([*c]const u8), @ptrCast([*c]u8, @alignCast(@import("std").meta.alignment([*c]u8), &buf)))), @bitCast(usize, @as(c_long, @as(c_int, 3)))); + } else { + var buf: [2]u8 = [2]u8{ + 208, + @ptrCast([*c]u8, @alignCast(@import("std").meta.alignment([*c]u8), &d))[@intCast(c_uint, @as(c_int, 0))], + }; + return x.*.callback.?(x.*.data, @ptrCast([*c]const u8, @alignCast(@import("std").meta.alignment([*c]const u8), @ptrCast([*c]u8, @alignCast(@import("std").meta.alignment([*c]u8), &buf)))), @bitCast(usize, @as(c_long, @as(c_int, 2)))); + } + } else if (@bitCast(c_int, @as(c_int, d)) < (@as(c_int, 1) << @intCast(@import("std").math.Log2Int(c_int), 7))) { + return x.*.callback.?(x.*.data, @ptrCast([*c]const u8, @alignCast(@import("std").meta.alignment([*c]const u8), &@ptrCast([*c]u8, @alignCast(@import("std").meta.alignment([*c]u8), &d))[@intCast(c_uint, @as(c_int, 0))])), @bitCast(usize, @as(c_long, @as(c_int, 1)))); + } else { + if (@bitCast(c_int, @as(c_int, d)) < (@as(c_int, 1) << @intCast(@import("std").math.Log2Int(c_int), 8))) { + var buf: [2]u8 = [2]u8{ + 204, + @ptrCast([*c]u8, @alignCast(@import("std").meta.alignment([*c]u8), &d))[@intCast(c_uint, @as(c_int, 0))], + }; + return x.*.callback.?(x.*.data, @ptrCast([*c]const u8, @alignCast(@import("std").meta.alignment([*c]const u8), @ptrCast([*c]u8, @alignCast(@import("std").meta.alignment([*c]u8), &buf)))), @bitCast(usize, @as(c_long, @as(c_int, 2)))); + } else { + var buf: [3]u8 = undefined; + buf[@intCast(c_uint, @as(c_int, 0))] = 205; + while (true) { + var val: u16 = ntohs(@bitCast(u16, d)); + _ = memcpy(@ptrCast(?*anyopaque, &buf[@intCast(c_uint, @as(c_int, 1))]), @ptrCast(?*const anyopaque, &val), @bitCast(c_ulong, @as(c_long, @as(c_int, 2)))); + if (!false) break; + } + return x.*.callback.?(x.*.data, @ptrCast([*c]const u8, @alignCast(@import("std").meta.alignment([*c]const u8), @ptrCast([*c]u8, @alignCast(@import("std").meta.alignment([*c]u8), &buf)))), @bitCast(usize, @as(c_long, @as(c_int, 3)))); + } + } + if (!false) break; + } + return 0; +} +pub fn msgpack_pack_int(arg_x: [*c]msgpack_packer, arg_d: c_int) callconv(.C) c_int { + var x = arg_x; + var d = arg_d; + while (true) { + if (d < -(@as(c_int, 1) << @intCast(@import("std").math.Log2Int(c_int), 5))) { + if (d < -(@as(c_int, 1) << @intCast(@import("std").math.Log2Int(c_int), 15))) { + var buf: [5]u8 = undefined; + buf[@intCast(c_uint, @as(c_int, 0))] = 210; + while (true) { + var val: u32 = ntohl(@bitCast(u32, @bitCast(i32, d))); + _ = memcpy(@ptrCast(?*anyopaque, &buf[@intCast(c_uint, @as(c_int, 1))]), @ptrCast(?*const anyopaque, &val), @bitCast(c_ulong, @as(c_long, @as(c_int, 4)))); + if (!false) break; + } + return x.*.callback.?(x.*.data, @ptrCast([*c]const u8, @alignCast(@import("std").meta.alignment([*c]const u8), @ptrCast([*c]u8, @alignCast(@import("std").meta.alignment([*c]u8), &buf)))), @bitCast(usize, @as(c_long, @as(c_int, 5)))); + } else if (d < -(@as(c_int, 1) << @intCast(@import("std").math.Log2Int(c_int), 7))) { + var buf: [3]u8 = undefined; + buf[@intCast(c_uint, @as(c_int, 0))] = 209; + while (true) { + var val: u16 = ntohs(@bitCast(u16, @bitCast(i16, @truncate(c_short, d)))); + _ = memcpy(@ptrCast(?*anyopaque, &buf[@intCast(c_uint, @as(c_int, 1))]), @ptrCast(?*const anyopaque, &val), @bitCast(c_ulong, @as(c_long, @as(c_int, 2)))); + if (!false) break; + } + return x.*.callback.?(x.*.data, @ptrCast([*c]const u8, @alignCast(@import("std").meta.alignment([*c]const u8), @ptrCast([*c]u8, @alignCast(@import("std").meta.alignment([*c]u8), &buf)))), @bitCast(usize, @as(c_long, @as(c_int, 3)))); + } else { + var buf: [2]u8 = [2]u8{ + 208, + @ptrCast([*c]u8, @alignCast(@import("std").meta.alignment([*c]u8), &d))[@intCast(c_uint, @as(c_int, 0))], + }; + return x.*.callback.?(x.*.data, @ptrCast([*c]const u8, @alignCast(@import("std").meta.alignment([*c]const u8), @ptrCast([*c]u8, @alignCast(@import("std").meta.alignment([*c]u8), &buf)))), @bitCast(usize, @as(c_long, @as(c_int, 2)))); + } + } else if (d < (@as(c_int, 1) << @intCast(@import("std").math.Log2Int(c_int), 7))) { + return x.*.callback.?(x.*.data, @ptrCast([*c]const u8, @alignCast(@import("std").meta.alignment([*c]const u8), &@ptrCast([*c]u8, @alignCast(@import("std").meta.alignment([*c]u8), &d))[@intCast(c_uint, @as(c_int, 0))])), @bitCast(usize, @as(c_long, @as(c_int, 1)))); + } else { + if (d < (@as(c_int, 1) << @intCast(@import("std").math.Log2Int(c_int), 8))) { + var buf: [2]u8 = [2]u8{ + 204, + @ptrCast([*c]u8, @alignCast(@import("std").meta.alignment([*c]u8), &d))[@intCast(c_uint, @as(c_int, 0))], + }; + return x.*.callback.?(x.*.data, @ptrCast([*c]const u8, @alignCast(@import("std").meta.alignment([*c]const u8), @ptrCast([*c]u8, @alignCast(@import("std").meta.alignment([*c]u8), &buf)))), @bitCast(usize, @as(c_long, @as(c_int, 2)))); + } else if (d < (@as(c_int, 1) << @intCast(@import("std").math.Log2Int(c_int), 16))) { + var buf: [3]u8 = undefined; + buf[@intCast(c_uint, @as(c_int, 0))] = 205; + while (true) { + var val: u16 = ntohs(@bitCast(u16, @truncate(c_short, d))); + _ = memcpy(@ptrCast(?*anyopaque, &buf[@intCast(c_uint, @as(c_int, 1))]), @ptrCast(?*const anyopaque, &val), @bitCast(c_ulong, @as(c_long, @as(c_int, 2)))); + if (!false) break; + } + return x.*.callback.?(x.*.data, @ptrCast([*c]const u8, @alignCast(@import("std").meta.alignment([*c]const u8), @ptrCast([*c]u8, @alignCast(@import("std").meta.alignment([*c]u8), &buf)))), @bitCast(usize, @as(c_long, @as(c_int, 3)))); + } else { + var buf: [5]u8 = undefined; + buf[@intCast(c_uint, @as(c_int, 0))] = 206; + while (true) { + var val: u32 = ntohl(@bitCast(u32, d)); + _ = memcpy(@ptrCast(?*anyopaque, &buf[@intCast(c_uint, @as(c_int, 1))]), @ptrCast(?*const anyopaque, &val), @bitCast(c_ulong, @as(c_long, @as(c_int, 4)))); + if (!false) break; + } + return x.*.callback.?(x.*.data, @ptrCast([*c]const u8, @alignCast(@import("std").meta.alignment([*c]const u8), @ptrCast([*c]u8, @alignCast(@import("std").meta.alignment([*c]u8), &buf)))), @bitCast(usize, @as(c_long, @as(c_int, 5)))); + } + } + if (!false) break; + } + return 0; +} +pub fn msgpack_pack_long(arg_x: [*c]msgpack_packer, arg_d: c_long) callconv(.C) c_int { + var x = arg_x; + var d = arg_d; + while (true) { + if (@bitCast(c_longlong, @as(c_longlong, d)) < -(@as(c_longlong, 1) << @intCast(@import("std").math.Log2Int(c_longlong), 5))) { + if (@bitCast(c_longlong, @as(c_longlong, d)) < -(@as(c_longlong, 1) << @intCast(@import("std").math.Log2Int(c_longlong), 15))) { + if (@bitCast(c_longlong, @as(c_longlong, d)) < -(@as(c_longlong, 1) << @intCast(@import("std").math.Log2Int(c_longlong), 31))) { + var buf: [9]u8 = undefined; + buf[@intCast(c_uint, @as(c_int, 0))] = 211; + while (true) { + var val: u64 = __bswap_64(@bitCast(__uint64_t, d)); + _ = memcpy(@ptrCast(?*anyopaque, &buf[@intCast(c_uint, @as(c_int, 1))]), @ptrCast(?*const anyopaque, &val), @bitCast(c_ulong, @as(c_long, @as(c_int, 8)))); + if (!false) break; + } + return x.*.callback.?(x.*.data, @ptrCast([*c]const u8, @alignCast(@import("std").meta.alignment([*c]const u8), @ptrCast([*c]u8, @alignCast(@import("std").meta.alignment([*c]u8), &buf)))), @bitCast(usize, @as(c_long, @as(c_int, 9)))); + } else { + var buf: [5]u8 = undefined; + buf[@intCast(c_uint, @as(c_int, 0))] = 210; + while (true) { + var val: u32 = ntohl(@bitCast(u32, @bitCast(i32, @truncate(c_int, d)))); + _ = memcpy(@ptrCast(?*anyopaque, &buf[@intCast(c_uint, @as(c_int, 1))]), @ptrCast(?*const anyopaque, &val), @bitCast(c_ulong, @as(c_long, @as(c_int, 4)))); + if (!false) break; + } + return x.*.callback.?(x.*.data, @ptrCast([*c]const u8, @alignCast(@import("std").meta.alignment([*c]const u8), @ptrCast([*c]u8, @alignCast(@import("std").meta.alignment([*c]u8), &buf)))), @bitCast(usize, @as(c_long, @as(c_int, 5)))); + } + } else { + if (d < @bitCast(c_long, @as(c_long, -(@as(c_int, 1) << @intCast(@import("std").math.Log2Int(c_int), 7))))) { + var buf: [3]u8 = undefined; + buf[@intCast(c_uint, @as(c_int, 0))] = 209; + while (true) { + var val: u16 = ntohs(@bitCast(u16, @bitCast(i16, @truncate(c_short, d)))); + _ = memcpy(@ptrCast(?*anyopaque, &buf[@intCast(c_uint, @as(c_int, 1))]), @ptrCast(?*const anyopaque, &val), @bitCast(c_ulong, @as(c_long, @as(c_int, 2)))); + if (!false) break; + } + return x.*.callback.?(x.*.data, @ptrCast([*c]const u8, @alignCast(@import("std").meta.alignment([*c]const u8), @ptrCast([*c]u8, @alignCast(@import("std").meta.alignment([*c]u8), &buf)))), @bitCast(usize, @as(c_long, @as(c_int, 3)))); + } else { + var buf: [2]u8 = [2]u8{ + 208, + @ptrCast([*c]u8, @alignCast(@import("std").meta.alignment([*c]u8), &d))[@intCast(c_uint, @as(c_int, 0))], + }; + return x.*.callback.?(x.*.data, @ptrCast([*c]const u8, @alignCast(@import("std").meta.alignment([*c]const u8), @ptrCast([*c]u8, @alignCast(@import("std").meta.alignment([*c]u8), &buf)))), @bitCast(usize, @as(c_long, @as(c_int, 2)))); + } + } + } else if (d < @bitCast(c_long, @as(c_long, @as(c_int, 1) << @intCast(@import("std").math.Log2Int(c_int), 7)))) { + return x.*.callback.?(x.*.data, @ptrCast([*c]const u8, @alignCast(@import("std").meta.alignment([*c]const u8), &@ptrCast([*c]u8, @alignCast(@import("std").meta.alignment([*c]u8), &d))[@intCast(c_uint, @as(c_int, 0))])), @bitCast(usize, @as(c_long, @as(c_int, 1)))); + } else { + if (@bitCast(c_longlong, @as(c_longlong, d)) < (@as(c_longlong, 1) << @intCast(@import("std").math.Log2Int(c_longlong), 16))) { + if (d < @bitCast(c_long, @as(c_long, @as(c_int, 1) << @intCast(@import("std").math.Log2Int(c_int), 8)))) { + var buf: [2]u8 = [2]u8{ + 204, + @ptrCast([*c]u8, @alignCast(@import("std").meta.alignment([*c]u8), &d))[@intCast(c_uint, @as(c_int, 0))], + }; + return x.*.callback.?(x.*.data, @ptrCast([*c]const u8, @alignCast(@import("std").meta.alignment([*c]const u8), @ptrCast([*c]u8, @alignCast(@import("std").meta.alignment([*c]u8), &buf)))), @bitCast(usize, @as(c_long, @as(c_int, 2)))); + } else { + var buf: [3]u8 = undefined; + buf[@intCast(c_uint, @as(c_int, 0))] = 205; + while (true) { + var val: u16 = ntohs(@bitCast(u16, @truncate(c_short, d))); + _ = memcpy(@ptrCast(?*anyopaque, &buf[@intCast(c_uint, @as(c_int, 1))]), @ptrCast(?*const anyopaque, &val), @bitCast(c_ulong, @as(c_long, @as(c_int, 2)))); + if (!false) break; + } + return x.*.callback.?(x.*.data, @ptrCast([*c]const u8, @alignCast(@import("std").meta.alignment([*c]const u8), @ptrCast([*c]u8, @alignCast(@import("std").meta.alignment([*c]u8), &buf)))), @bitCast(usize, @as(c_long, @as(c_int, 3)))); + } + } else { + if (@bitCast(c_longlong, @as(c_longlong, d)) < (@as(c_longlong, 1) << @intCast(@import("std").math.Log2Int(c_longlong), 32))) { + var buf: [5]u8 = undefined; + buf[@intCast(c_uint, @as(c_int, 0))] = 206; + while (true) { + var val: u32 = ntohl(@bitCast(u32, @truncate(c_int, d))); + _ = memcpy(@ptrCast(?*anyopaque, &buf[@intCast(c_uint, @as(c_int, 1))]), @ptrCast(?*const anyopaque, &val), @bitCast(c_ulong, @as(c_long, @as(c_int, 4)))); + if (!false) break; + } + return x.*.callback.?(x.*.data, @ptrCast([*c]const u8, @alignCast(@import("std").meta.alignment([*c]const u8), @ptrCast([*c]u8, @alignCast(@import("std").meta.alignment([*c]u8), &buf)))), @bitCast(usize, @as(c_long, @as(c_int, 5)))); + } else { + var buf: [9]u8 = undefined; + buf[@intCast(c_uint, @as(c_int, 0))] = 207; + while (true) { + var val: u64 = __bswap_64(@bitCast(__uint64_t, d)); + _ = memcpy(@ptrCast(?*anyopaque, &buf[@intCast(c_uint, @as(c_int, 1))]), @ptrCast(?*const anyopaque, &val), @bitCast(c_ulong, @as(c_long, @as(c_int, 8)))); + if (!false) break; + } + return x.*.callback.?(x.*.data, @ptrCast([*c]const u8, @alignCast(@import("std").meta.alignment([*c]const u8), @ptrCast([*c]u8, @alignCast(@import("std").meta.alignment([*c]u8), &buf)))), @bitCast(usize, @as(c_long, @as(c_int, 9)))); + } + } + } + if (!false) break; + } + return 0; +} +pub fn msgpack_pack_long_long(arg_x: [*c]msgpack_packer, arg_d: c_longlong) callconv(.C) c_int { + var x = arg_x; + var d = arg_d; + while (true) { + if (d < -(@as(c_longlong, 1) << @intCast(@import("std").math.Log2Int(c_longlong), 5))) { + if (d < -(@as(c_longlong, 1) << @intCast(@import("std").math.Log2Int(c_longlong), 15))) { + if (d < -(@as(c_longlong, 1) << @intCast(@import("std").math.Log2Int(c_longlong), 31))) { + var buf: [9]u8 = undefined; + buf[@intCast(c_uint, @as(c_int, 0))] = 211; + while (true) { + var val: u64 = __bswap_64(@bitCast(__uint64_t, @truncate(c_long, d))); + _ = memcpy(@ptrCast(?*anyopaque, &buf[@intCast(c_uint, @as(c_int, 1))]), @ptrCast(?*const anyopaque, &val), @bitCast(c_ulong, @as(c_long, @as(c_int, 8)))); + if (!false) break; + } + return x.*.callback.?(x.*.data, @ptrCast([*c]const u8, @alignCast(@import("std").meta.alignment([*c]const u8), @ptrCast([*c]u8, @alignCast(@import("std").meta.alignment([*c]u8), &buf)))), @bitCast(usize, @as(c_long, @as(c_int, 9)))); + } else { + var buf: [5]u8 = undefined; + buf[@intCast(c_uint, @as(c_int, 0))] = 210; + while (true) { + var val: u32 = ntohl(@bitCast(u32, @bitCast(i32, @truncate(c_int, d)))); + _ = memcpy(@ptrCast(?*anyopaque, &buf[@intCast(c_uint, @as(c_int, 1))]), @ptrCast(?*const anyopaque, &val), @bitCast(c_ulong, @as(c_long, @as(c_int, 4)))); + if (!false) break; + } + return x.*.callback.?(x.*.data, @ptrCast([*c]const u8, @alignCast(@import("std").meta.alignment([*c]const u8), @ptrCast([*c]u8, @alignCast(@import("std").meta.alignment([*c]u8), &buf)))), @bitCast(usize, @as(c_long, @as(c_int, 5)))); + } + } else { + if (d < @bitCast(c_longlong, @as(c_longlong, -(@as(c_int, 1) << @intCast(@import("std").math.Log2Int(c_int), 7))))) { + var buf: [3]u8 = undefined; + buf[@intCast(c_uint, @as(c_int, 0))] = 209; + while (true) { + var val: u16 = ntohs(@bitCast(u16, @bitCast(i16, @truncate(c_short, d)))); + _ = memcpy(@ptrCast(?*anyopaque, &buf[@intCast(c_uint, @as(c_int, 1))]), @ptrCast(?*const anyopaque, &val), @bitCast(c_ulong, @as(c_long, @as(c_int, 2)))); + if (!false) break; + } + return x.*.callback.?(x.*.data, @ptrCast([*c]const u8, @alignCast(@import("std").meta.alignment([*c]const u8), @ptrCast([*c]u8, @alignCast(@import("std").meta.alignment([*c]u8), &buf)))), @bitCast(usize, @as(c_long, @as(c_int, 3)))); + } else { + var buf: [2]u8 = [2]u8{ + 208, + @ptrCast([*c]u8, @alignCast(@import("std").meta.alignment([*c]u8), &d))[@intCast(c_uint, @as(c_int, 0))], + }; + return x.*.callback.?(x.*.data, @ptrCast([*c]const u8, @alignCast(@import("std").meta.alignment([*c]const u8), @ptrCast([*c]u8, @alignCast(@import("std").meta.alignment([*c]u8), &buf)))), @bitCast(usize, @as(c_long, @as(c_int, 2)))); + } + } + } else if (d < @bitCast(c_longlong, @as(c_longlong, @as(c_int, 1) << @intCast(@import("std").math.Log2Int(c_int), 7)))) { + return x.*.callback.?(x.*.data, @ptrCast([*c]const u8, @alignCast(@import("std").meta.alignment([*c]const u8), &@ptrCast([*c]u8, @alignCast(@import("std").meta.alignment([*c]u8), &d))[@intCast(c_uint, @as(c_int, 0))])), @bitCast(usize, @as(c_long, @as(c_int, 1)))); + } else { + if (d < (@as(c_longlong, 1) << @intCast(@import("std").math.Log2Int(c_longlong), 16))) { + if (d < @bitCast(c_longlong, @as(c_longlong, @as(c_int, 1) << @intCast(@import("std").math.Log2Int(c_int), 8)))) { + var buf: [2]u8 = [2]u8{ + 204, + @ptrCast([*c]u8, @alignCast(@import("std").meta.alignment([*c]u8), &d))[@intCast(c_uint, @as(c_int, 0))], + }; + return x.*.callback.?(x.*.data, @ptrCast([*c]const u8, @alignCast(@import("std").meta.alignment([*c]const u8), @ptrCast([*c]u8, @alignCast(@import("std").meta.alignment([*c]u8), &buf)))), @bitCast(usize, @as(c_long, @as(c_int, 2)))); + } else { + var buf: [3]u8 = undefined; + buf[@intCast(c_uint, @as(c_int, 0))] = 205; + while (true) { + var val: u16 = ntohs(@bitCast(u16, @truncate(c_short, d))); + _ = memcpy(@ptrCast(?*anyopaque, &buf[@intCast(c_uint, @as(c_int, 1))]), @ptrCast(?*const anyopaque, &val), @bitCast(c_ulong, @as(c_long, @as(c_int, 2)))); + if (!false) break; + } + return x.*.callback.?(x.*.data, @ptrCast([*c]const u8, @alignCast(@import("std").meta.alignment([*c]const u8), @ptrCast([*c]u8, @alignCast(@import("std").meta.alignment([*c]u8), &buf)))), @bitCast(usize, @as(c_long, @as(c_int, 3)))); + } + } else { + if (d < (@as(c_longlong, 1) << @intCast(@import("std").math.Log2Int(c_longlong), 32))) { + var buf: [5]u8 = undefined; + buf[@intCast(c_uint, @as(c_int, 0))] = 206; + while (true) { + var val: u32 = ntohl(@bitCast(u32, @truncate(c_int, d))); + _ = memcpy(@ptrCast(?*anyopaque, &buf[@intCast(c_uint, @as(c_int, 1))]), @ptrCast(?*const anyopaque, &val), @bitCast(c_ulong, @as(c_long, @as(c_int, 4)))); + if (!false) break; + } + return x.*.callback.?(x.*.data, @ptrCast([*c]const u8, @alignCast(@import("std").meta.alignment([*c]const u8), @ptrCast([*c]u8, @alignCast(@import("std").meta.alignment([*c]u8), &buf)))), @bitCast(usize, @as(c_long, @as(c_int, 5)))); + } else { + var buf: [9]u8 = undefined; + buf[@intCast(c_uint, @as(c_int, 0))] = 207; + while (true) { + var val: u64 = __bswap_64(@bitCast(__uint64_t, @truncate(c_long, d))); + _ = memcpy(@ptrCast(?*anyopaque, &buf[@intCast(c_uint, @as(c_int, 1))]), @ptrCast(?*const anyopaque, &val), @bitCast(c_ulong, @as(c_long, @as(c_int, 8)))); + if (!false) break; + } + return x.*.callback.?(x.*.data, @ptrCast([*c]const u8, @alignCast(@import("std").meta.alignment([*c]const u8), @ptrCast([*c]u8, @alignCast(@import("std").meta.alignment([*c]u8), &buf)))), @bitCast(usize, @as(c_long, @as(c_int, 9)))); + } + } + } + if (!false) break; + } + return 0; +} +pub fn msgpack_pack_unsigned_char(arg_x: [*c]msgpack_packer, arg_d: u8) callconv(.C) c_int { + var x = arg_x; + var d = arg_d; + while (true) { + if (@bitCast(c_int, @as(c_uint, d)) < (@as(c_int, 1) << @intCast(@import("std").math.Log2Int(c_int), 7))) { + return x.*.callback.?(x.*.data, @ptrCast([*c]const u8, @alignCast(@import("std").meta.alignment([*c]const u8), &@ptrCast([*c]u8, @alignCast(@import("std").meta.alignment([*c]u8), &d))[@intCast(c_uint, @as(c_int, 0))])), @bitCast(usize, @as(c_long, @as(c_int, 1)))); + } else { + var buf: [2]u8 = [2]u8{ + 204, + @ptrCast([*c]u8, @alignCast(@import("std").meta.alignment([*c]u8), &d))[@intCast(c_uint, @as(c_int, 0))], + }; + return x.*.callback.?(x.*.data, @ptrCast([*c]const u8, @alignCast(@import("std").meta.alignment([*c]const u8), @ptrCast([*c]u8, @alignCast(@import("std").meta.alignment([*c]u8), &buf)))), @bitCast(usize, @as(c_long, @as(c_int, 2)))); + } + if (!false) break; + } + return 0; +} +pub fn msgpack_pack_unsigned_short(arg_x: [*c]msgpack_packer, arg_d: c_ushort) callconv(.C) c_int { + var x = arg_x; + var d = arg_d; + while (true) { + if (@bitCast(c_int, @as(c_uint, d)) < (@as(c_int, 1) << @intCast(@import("std").math.Log2Int(c_int), 7))) { + return x.*.callback.?(x.*.data, @ptrCast([*c]const u8, @alignCast(@import("std").meta.alignment([*c]const u8), &@ptrCast([*c]u8, @alignCast(@import("std").meta.alignment([*c]u8), &d))[@intCast(c_uint, @as(c_int, 0))])), @bitCast(usize, @as(c_long, @as(c_int, 1)))); + } else if (@bitCast(c_int, @as(c_uint, d)) < (@as(c_int, 1) << @intCast(@import("std").math.Log2Int(c_int), 8))) { + var buf: [2]u8 = [2]u8{ + 204, + @ptrCast([*c]u8, @alignCast(@import("std").meta.alignment([*c]u8), &d))[@intCast(c_uint, @as(c_int, 0))], + }; + return x.*.callback.?(x.*.data, @ptrCast([*c]const u8, @alignCast(@import("std").meta.alignment([*c]const u8), @ptrCast([*c]u8, @alignCast(@import("std").meta.alignment([*c]u8), &buf)))), @bitCast(usize, @as(c_long, @as(c_int, 2)))); + } else { + var buf: [3]u8 = undefined; + buf[@intCast(c_uint, @as(c_int, 0))] = 205; + while (true) { + var val: u16 = ntohs(@bitCast(u16, d)); + _ = memcpy(@ptrCast(?*anyopaque, &buf[@intCast(c_uint, @as(c_int, 1))]), @ptrCast(?*const anyopaque, &val), @bitCast(c_ulong, @as(c_long, @as(c_int, 2)))); + if (!false) break; + } + return x.*.callback.?(x.*.data, @ptrCast([*c]const u8, @alignCast(@import("std").meta.alignment([*c]const u8), @ptrCast([*c]u8, @alignCast(@import("std").meta.alignment([*c]u8), &buf)))), @bitCast(usize, @as(c_long, @as(c_int, 3)))); + } + if (!false) break; + } + return 0; +} +pub fn msgpack_pack_unsigned_int(arg_x: [*c]msgpack_packer, arg_d: c_uint) callconv(.C) c_int { + var x = arg_x; + var d = arg_d; + while (true) { + if (d < @bitCast(c_uint, @as(c_int, 1) << @intCast(@import("std").math.Log2Int(c_int), 8))) { + if (d < @bitCast(c_uint, @as(c_int, 1) << @intCast(@import("std").math.Log2Int(c_int), 7))) { + return x.*.callback.?(x.*.data, @ptrCast([*c]const u8, @alignCast(@import("std").meta.alignment([*c]const u8), &@ptrCast([*c]u8, @alignCast(@import("std").meta.alignment([*c]u8), &d))[@intCast(c_uint, @as(c_int, 0))])), @bitCast(usize, @as(c_long, @as(c_int, 1)))); + } else { + var buf: [2]u8 = [2]u8{ + 204, + @ptrCast([*c]u8, @alignCast(@import("std").meta.alignment([*c]u8), &d))[@intCast(c_uint, @as(c_int, 0))], + }; + return x.*.callback.?(x.*.data, @ptrCast([*c]const u8, @alignCast(@import("std").meta.alignment([*c]const u8), @ptrCast([*c]u8, @alignCast(@import("std").meta.alignment([*c]u8), &buf)))), @bitCast(usize, @as(c_long, @as(c_int, 2)))); + } + } else { + if (d < @bitCast(c_uint, @as(c_int, 1) << @intCast(@import("std").math.Log2Int(c_int), 16))) { + var buf: [3]u8 = undefined; + buf[@intCast(c_uint, @as(c_int, 0))] = 205; + while (true) { + var val: u16 = ntohs(@bitCast(u16, @truncate(c_ushort, d))); + _ = memcpy(@ptrCast(?*anyopaque, &buf[@intCast(c_uint, @as(c_int, 1))]), @ptrCast(?*const anyopaque, &val), @bitCast(c_ulong, @as(c_long, @as(c_int, 2)))); + if (!false) break; + } + return x.*.callback.?(x.*.data, @ptrCast([*c]const u8, @alignCast(@import("std").meta.alignment([*c]const u8), @ptrCast([*c]u8, @alignCast(@import("std").meta.alignment([*c]u8), &buf)))), @bitCast(usize, @as(c_long, @as(c_int, 3)))); + } else { + var buf: [5]u8 = undefined; + buf[@intCast(c_uint, @as(c_int, 0))] = 206; + while (true) { + var val: u32 = ntohl(@bitCast(u32, d)); + _ = memcpy(@ptrCast(?*anyopaque, &buf[@intCast(c_uint, @as(c_int, 1))]), @ptrCast(?*const anyopaque, &val), @bitCast(c_ulong, @as(c_long, @as(c_int, 4)))); + if (!false) break; + } + return x.*.callback.?(x.*.data, @ptrCast([*c]const u8, @alignCast(@import("std").meta.alignment([*c]const u8), @ptrCast([*c]u8, @alignCast(@import("std").meta.alignment([*c]u8), &buf)))), @bitCast(usize, @as(c_long, @as(c_int, 5)))); + } + } + if (!false) break; + } + return 0; +} +pub fn msgpack_pack_unsigned_long(arg_x: [*c]msgpack_packer, arg_d: c_ulong) callconv(.C) c_int { + var x = arg_x; + var d = arg_d; + while (true) { + if (@bitCast(c_ulonglong, @as(c_ulonglong, d)) < (@as(c_ulonglong, 1) << @intCast(@import("std").math.Log2Int(c_ulonglong), 8))) { + if (@bitCast(c_ulonglong, @as(c_ulonglong, d)) < (@as(c_ulonglong, 1) << @intCast(@import("std").math.Log2Int(c_ulonglong), 7))) { + return x.*.callback.?(x.*.data, @ptrCast([*c]const u8, @alignCast(@import("std").meta.alignment([*c]const u8), &@ptrCast([*c]u8, @alignCast(@import("std").meta.alignment([*c]u8), &d))[@intCast(c_uint, @as(c_int, 0))])), @bitCast(usize, @as(c_long, @as(c_int, 1)))); + } else { + var buf: [2]u8 = [2]u8{ + 204, + @ptrCast([*c]u8, @alignCast(@import("std").meta.alignment([*c]u8), &d))[@intCast(c_uint, @as(c_int, 0))], + }; + return x.*.callback.?(x.*.data, @ptrCast([*c]const u8, @alignCast(@import("std").meta.alignment([*c]const u8), @ptrCast([*c]u8, @alignCast(@import("std").meta.alignment([*c]u8), &buf)))), @bitCast(usize, @as(c_long, @as(c_int, 2)))); + } + } else { + if (@bitCast(c_ulonglong, @as(c_ulonglong, d)) < (@as(c_ulonglong, 1) << @intCast(@import("std").math.Log2Int(c_ulonglong), 16))) { + var buf: [3]u8 = undefined; + buf[@intCast(c_uint, @as(c_int, 0))] = 205; + while (true) { + var val: u16 = ntohs(@bitCast(u16, @truncate(c_ushort, d))); + _ = memcpy(@ptrCast(?*anyopaque, &buf[@intCast(c_uint, @as(c_int, 1))]), @ptrCast(?*const anyopaque, &val), @bitCast(c_ulong, @as(c_long, @as(c_int, 2)))); + if (!false) break; + } + return x.*.callback.?(x.*.data, @ptrCast([*c]const u8, @alignCast(@import("std").meta.alignment([*c]const u8), @ptrCast([*c]u8, @alignCast(@import("std").meta.alignment([*c]u8), &buf)))), @bitCast(usize, @as(c_long, @as(c_int, 3)))); + } else if (@bitCast(c_ulonglong, @as(c_ulonglong, d)) < (@as(c_ulonglong, 1) << @intCast(@import("std").math.Log2Int(c_ulonglong), 32))) { + var buf: [5]u8 = undefined; + buf[@intCast(c_uint, @as(c_int, 0))] = 206; + while (true) { + var val: u32 = ntohl(@bitCast(u32, @truncate(c_uint, d))); + _ = memcpy(@ptrCast(?*anyopaque, &buf[@intCast(c_uint, @as(c_int, 1))]), @ptrCast(?*const anyopaque, &val), @bitCast(c_ulong, @as(c_long, @as(c_int, 4)))); + if (!false) break; + } + return x.*.callback.?(x.*.data, @ptrCast([*c]const u8, @alignCast(@import("std").meta.alignment([*c]const u8), @ptrCast([*c]u8, @alignCast(@import("std").meta.alignment([*c]u8), &buf)))), @bitCast(usize, @as(c_long, @as(c_int, 5)))); + } else { + var buf: [9]u8 = undefined; + buf[@intCast(c_uint, @as(c_int, 0))] = 207; + while (true) { + var val: u64 = __bswap_64(d); + _ = memcpy(@ptrCast(?*anyopaque, &buf[@intCast(c_uint, @as(c_int, 1))]), @ptrCast(?*const anyopaque, &val), @bitCast(c_ulong, @as(c_long, @as(c_int, 8)))); + if (!false) break; + } + return x.*.callback.?(x.*.data, @ptrCast([*c]const u8, @alignCast(@import("std").meta.alignment([*c]const u8), @ptrCast([*c]u8, @alignCast(@import("std").meta.alignment([*c]u8), &buf)))), @bitCast(usize, @as(c_long, @as(c_int, 9)))); + } + } + if (!false) break; + } + return 0; +} +pub fn msgpack_pack_unsigned_long_long(arg_x: [*c]msgpack_packer, arg_d: c_ulonglong) callconv(.C) c_int { + var x = arg_x; + var d = arg_d; + while (true) { + if (d < (@as(c_ulonglong, 1) << @intCast(@import("std").math.Log2Int(c_ulonglong), 8))) { + if (d < (@as(c_ulonglong, 1) << @intCast(@import("std").math.Log2Int(c_ulonglong), 7))) { + return x.*.callback.?(x.*.data, @ptrCast([*c]const u8, @alignCast(@import("std").meta.alignment([*c]const u8), &@ptrCast([*c]u8, @alignCast(@import("std").meta.alignment([*c]u8), &d))[@intCast(c_uint, @as(c_int, 0))])), @bitCast(usize, @as(c_long, @as(c_int, 1)))); + } else { + var buf: [2]u8 = [2]u8{ + 204, + @ptrCast([*c]u8, @alignCast(@import("std").meta.alignment([*c]u8), &d))[@intCast(c_uint, @as(c_int, 0))], + }; + return x.*.callback.?(x.*.data, @ptrCast([*c]const u8, @alignCast(@import("std").meta.alignment([*c]const u8), @ptrCast([*c]u8, @alignCast(@import("std").meta.alignment([*c]u8), &buf)))), @bitCast(usize, @as(c_long, @as(c_int, 2)))); + } + } else { + if (d < (@as(c_ulonglong, 1) << @intCast(@import("std").math.Log2Int(c_ulonglong), 16))) { + var buf: [3]u8 = undefined; + buf[@intCast(c_uint, @as(c_int, 0))] = 205; + while (true) { + var val: u16 = ntohs(@bitCast(u16, @truncate(c_ushort, d))); + _ = memcpy(@ptrCast(?*anyopaque, &buf[@intCast(c_uint, @as(c_int, 1))]), @ptrCast(?*const anyopaque, &val), @bitCast(c_ulong, @as(c_long, @as(c_int, 2)))); + if (!false) break; + } + return x.*.callback.?(x.*.data, @ptrCast([*c]const u8, @alignCast(@import("std").meta.alignment([*c]const u8), @ptrCast([*c]u8, @alignCast(@import("std").meta.alignment([*c]u8), &buf)))), @bitCast(usize, @as(c_long, @as(c_int, 3)))); + } else if (d < (@as(c_ulonglong, 1) << @intCast(@import("std").math.Log2Int(c_ulonglong), 32))) { + var buf: [5]u8 = undefined; + buf[@intCast(c_uint, @as(c_int, 0))] = 206; + while (true) { + var val: u32 = ntohl(@bitCast(u32, @truncate(c_uint, d))); + _ = memcpy(@ptrCast(?*anyopaque, &buf[@intCast(c_uint, @as(c_int, 1))]), @ptrCast(?*const anyopaque, &val), @bitCast(c_ulong, @as(c_long, @as(c_int, 4)))); + if (!false) break; + } + return x.*.callback.?(x.*.data, @ptrCast([*c]const u8, @alignCast(@import("std").meta.alignment([*c]const u8), @ptrCast([*c]u8, @alignCast(@import("std").meta.alignment([*c]u8), &buf)))), @bitCast(usize, @as(c_long, @as(c_int, 5)))); + } else { + var buf: [9]u8 = undefined; + buf[@intCast(c_uint, @as(c_int, 0))] = 207; + while (true) { + var val: u64 = __bswap_64(@bitCast(__uint64_t, @truncate(c_ulong, d))); + _ = memcpy(@ptrCast(?*anyopaque, &buf[@intCast(c_uint, @as(c_int, 1))]), @ptrCast(?*const anyopaque, &val), @bitCast(c_ulong, @as(c_long, @as(c_int, 8)))); + if (!false) break; + } + return x.*.callback.?(x.*.data, @ptrCast([*c]const u8, @alignCast(@import("std").meta.alignment([*c]const u8), @ptrCast([*c]u8, @alignCast(@import("std").meta.alignment([*c]u8), &buf)))), @bitCast(usize, @as(c_long, @as(c_int, 9)))); + } + } + if (!false) break; + } + return 0; +} +pub fn msgpack_pack_uint8(arg_x: [*c]msgpack_packer, arg_d: u8) callconv(.C) c_int { + var x = arg_x; + var d = arg_d; + while (true) { + if (@bitCast(c_int, @as(c_uint, d)) < (@as(c_int, 1) << @intCast(@import("std").math.Log2Int(c_int), 7))) { + return x.*.callback.?(x.*.data, @ptrCast([*c]const u8, @alignCast(@import("std").meta.alignment([*c]const u8), &(&d)[@intCast(c_uint, @as(c_int, 0))])), @bitCast(usize, @as(c_long, @as(c_int, 1)))); + } else { + var buf: [2]u8 = [2]u8{ + 204, + (&d)[@intCast(c_uint, @as(c_int, 0))], + }; + return x.*.callback.?(x.*.data, @ptrCast([*c]const u8, @alignCast(@import("std").meta.alignment([*c]const u8), @ptrCast([*c]u8, @alignCast(@import("std").meta.alignment([*c]u8), &buf)))), @bitCast(usize, @as(c_long, @as(c_int, 2)))); + } + if (!false) break; + } + return 0; +} +pub fn msgpack_pack_uint16(arg_x: [*c]msgpack_packer, arg_d: u16) callconv(.C) c_int { + var x = arg_x; + var d = arg_d; + while (true) { + if (@bitCast(c_int, @as(c_uint, d)) < (@as(c_int, 1) << @intCast(@import("std").math.Log2Int(c_int), 7))) { + return x.*.callback.?(x.*.data, @ptrCast([*c]const u8, @alignCast(@import("std").meta.alignment([*c]const u8), &@ptrCast([*c]u8, @alignCast(@import("std").meta.alignment([*c]u8), &d))[@intCast(c_uint, @as(c_int, 0))])), @bitCast(usize, @as(c_long, @as(c_int, 1)))); + } else if (@bitCast(c_int, @as(c_uint, d)) < (@as(c_int, 1) << @intCast(@import("std").math.Log2Int(c_int), 8))) { + var buf: [2]u8 = [2]u8{ + 204, + @ptrCast([*c]u8, @alignCast(@import("std").meta.alignment([*c]u8), &d))[@intCast(c_uint, @as(c_int, 0))], + }; + return x.*.callback.?(x.*.data, @ptrCast([*c]const u8, @alignCast(@import("std").meta.alignment([*c]const u8), @ptrCast([*c]u8, @alignCast(@import("std").meta.alignment([*c]u8), &buf)))), @bitCast(usize, @as(c_long, @as(c_int, 2)))); + } else { + var buf: [3]u8 = undefined; + buf[@intCast(c_uint, @as(c_int, 0))] = 205; + while (true) { + var val: u16 = ntohs(d); + _ = memcpy(@ptrCast(?*anyopaque, &buf[@intCast(c_uint, @as(c_int, 1))]), @ptrCast(?*const anyopaque, &val), @bitCast(c_ulong, @as(c_long, @as(c_int, 2)))); + if (!false) break; + } + return x.*.callback.?(x.*.data, @ptrCast([*c]const u8, @alignCast(@import("std").meta.alignment([*c]const u8), @ptrCast([*c]u8, @alignCast(@import("std").meta.alignment([*c]u8), &buf)))), @bitCast(usize, @as(c_long, @as(c_int, 3)))); + } + if (!false) break; + } + return 0; +} +pub fn msgpack_pack_uint32(arg_x: [*c]msgpack_packer, arg_d: u32) callconv(.C) c_int { + var x = arg_x; + var d = arg_d; + while (true) { + if (d < @bitCast(u32, @as(c_int, 1) << @intCast(@import("std").math.Log2Int(c_int), 8))) { + if (d < @bitCast(u32, @as(c_int, 1) << @intCast(@import("std").math.Log2Int(c_int), 7))) { + return x.*.callback.?(x.*.data, @ptrCast([*c]const u8, @alignCast(@import("std").meta.alignment([*c]const u8), &@ptrCast([*c]u8, @alignCast(@import("std").meta.alignment([*c]u8), &d))[@intCast(c_uint, @as(c_int, 0))])), @bitCast(usize, @as(c_long, @as(c_int, 1)))); + } else { + var buf: [2]u8 = [2]u8{ + 204, + @ptrCast([*c]u8, @alignCast(@import("std").meta.alignment([*c]u8), &d))[@intCast(c_uint, @as(c_int, 0))], + }; + return x.*.callback.?(x.*.data, @ptrCast([*c]const u8, @alignCast(@import("std").meta.alignment([*c]const u8), @ptrCast([*c]u8, @alignCast(@import("std").meta.alignment([*c]u8), &buf)))), @bitCast(usize, @as(c_long, @as(c_int, 2)))); + } + } else { + if (d < @bitCast(u32, @as(c_int, 1) << @intCast(@import("std").math.Log2Int(c_int), 16))) { + var buf: [3]u8 = undefined; + buf[@intCast(c_uint, @as(c_int, 0))] = 205; + while (true) { + var val: u16 = ntohs(@bitCast(u16, @truncate(c_ushort, d))); + _ = memcpy(@ptrCast(?*anyopaque, &buf[@intCast(c_uint, @as(c_int, 1))]), @ptrCast(?*const anyopaque, &val), @bitCast(c_ulong, @as(c_long, @as(c_int, 2)))); + if (!false) break; + } + return x.*.callback.?(x.*.data, @ptrCast([*c]const u8, @alignCast(@import("std").meta.alignment([*c]const u8), @ptrCast([*c]u8, @alignCast(@import("std").meta.alignment([*c]u8), &buf)))), @bitCast(usize, @as(c_long, @as(c_int, 3)))); + } else { + var buf: [5]u8 = undefined; + buf[@intCast(c_uint, @as(c_int, 0))] = 206; + while (true) { + var val: u32 = ntohl(d); + _ = memcpy(@ptrCast(?*anyopaque, &buf[@intCast(c_uint, @as(c_int, 1))]), @ptrCast(?*const anyopaque, &val), @bitCast(c_ulong, @as(c_long, @as(c_int, 4)))); + if (!false) break; + } + return x.*.callback.?(x.*.data, @ptrCast([*c]const u8, @alignCast(@import("std").meta.alignment([*c]const u8), @ptrCast([*c]u8, @alignCast(@import("std").meta.alignment([*c]u8), &buf)))), @bitCast(usize, @as(c_long, @as(c_int, 5)))); + } + } + if (!false) break; + } + return 0; +} +pub fn msgpack_pack_uint64(arg_x: [*c]msgpack_packer, arg_d: u64) callconv(.C) c_int { + var x = arg_x; + var d = arg_d; + while (true) { + if (@bitCast(c_ulonglong, @as(c_ulonglong, d)) < (@as(c_ulonglong, 1) << @intCast(@import("std").math.Log2Int(c_ulonglong), 8))) { + if (@bitCast(c_ulonglong, @as(c_ulonglong, d)) < (@as(c_ulonglong, 1) << @intCast(@import("std").math.Log2Int(c_ulonglong), 7))) { + return x.*.callback.?(x.*.data, @ptrCast([*c]const u8, @alignCast(@import("std").meta.alignment([*c]const u8), &@ptrCast([*c]u8, @alignCast(@import("std").meta.alignment([*c]u8), &d))[@intCast(c_uint, @as(c_int, 0))])), @bitCast(usize, @as(c_long, @as(c_int, 1)))); + } else { + var buf: [2]u8 = [2]u8{ + 204, + @ptrCast([*c]u8, @alignCast(@import("std").meta.alignment([*c]u8), &d))[@intCast(c_uint, @as(c_int, 0))], + }; + return x.*.callback.?(x.*.data, @ptrCast([*c]const u8, @alignCast(@import("std").meta.alignment([*c]const u8), @ptrCast([*c]u8, @alignCast(@import("std").meta.alignment([*c]u8), &buf)))), @bitCast(usize, @as(c_long, @as(c_int, 2)))); + } + } else { + if (@bitCast(c_ulonglong, @as(c_ulonglong, d)) < (@as(c_ulonglong, 1) << @intCast(@import("std").math.Log2Int(c_ulonglong), 16))) { + var buf: [3]u8 = undefined; + buf[@intCast(c_uint, @as(c_int, 0))] = 205; + while (true) { + var val: u16 = ntohs(@bitCast(u16, @truncate(c_ushort, d))); + _ = memcpy(@ptrCast(?*anyopaque, &buf[@intCast(c_uint, @as(c_int, 1))]), @ptrCast(?*const anyopaque, &val), @bitCast(c_ulong, @as(c_long, @as(c_int, 2)))); + if (!false) break; + } + return x.*.callback.?(x.*.data, @ptrCast([*c]const u8, @alignCast(@import("std").meta.alignment([*c]const u8), @ptrCast([*c]u8, @alignCast(@import("std").meta.alignment([*c]u8), &buf)))), @bitCast(usize, @as(c_long, @as(c_int, 3)))); + } else if (@bitCast(c_ulonglong, @as(c_ulonglong, d)) < (@as(c_ulonglong, 1) << @intCast(@import("std").math.Log2Int(c_ulonglong), 32))) { + var buf: [5]u8 = undefined; + buf[@intCast(c_uint, @as(c_int, 0))] = 206; + while (true) { + var val: u32 = ntohl(@bitCast(u32, @truncate(c_uint, d))); + _ = memcpy(@ptrCast(?*anyopaque, &buf[@intCast(c_uint, @as(c_int, 1))]), @ptrCast(?*const anyopaque, &val), @bitCast(c_ulong, @as(c_long, @as(c_int, 4)))); + if (!false) break; + } + return x.*.callback.?(x.*.data, @ptrCast([*c]const u8, @alignCast(@import("std").meta.alignment([*c]const u8), @ptrCast([*c]u8, @alignCast(@import("std").meta.alignment([*c]u8), &buf)))), @bitCast(usize, @as(c_long, @as(c_int, 5)))); + } else { + var buf: [9]u8 = undefined; + buf[@intCast(c_uint, @as(c_int, 0))] = 207; + while (true) { + var val: u64 = __bswap_64(d); + _ = memcpy(@ptrCast(?*anyopaque, &buf[@intCast(c_uint, @as(c_int, 1))]), @ptrCast(?*const anyopaque, &val), @bitCast(c_ulong, @as(c_long, @as(c_int, 8)))); + if (!false) break; + } + return x.*.callback.?(x.*.data, @ptrCast([*c]const u8, @alignCast(@import("std").meta.alignment([*c]const u8), @ptrCast([*c]u8, @alignCast(@import("std").meta.alignment([*c]u8), &buf)))), @bitCast(usize, @as(c_long, @as(c_int, 9)))); + } + } + if (!false) break; + } + return 0; +} +pub fn msgpack_pack_int8(arg_x: [*c]msgpack_packer, arg_d: i8) callconv(.C) c_int { + var x = arg_x; + var d = arg_d; + while (true) { + if (@bitCast(c_int, @as(c_int, d)) < -(@as(c_int, 1) << @intCast(@import("std").math.Log2Int(c_int), 5))) { + var buf: [2]u8 = [2]u8{ + 208, + @ptrCast([*c]u8, @alignCast(@import("std").meta.alignment([*c]u8), &d))[@intCast(c_uint, @as(c_int, 0))], + }; + return x.*.callback.?(x.*.data, @ptrCast([*c]const u8, @alignCast(@import("std").meta.alignment([*c]const u8), @ptrCast([*c]u8, @alignCast(@import("std").meta.alignment([*c]u8), &buf)))), @bitCast(usize, @as(c_long, @as(c_int, 2)))); + } else { + return x.*.callback.?(x.*.data, @ptrCast([*c]const u8, @alignCast(@import("std").meta.alignment([*c]const u8), &@ptrCast([*c]u8, @alignCast(@import("std").meta.alignment([*c]u8), &d))[@intCast(c_uint, @as(c_int, 0))])), @bitCast(usize, @as(c_long, @as(c_int, 1)))); + } + if (!false) break; + } + return 0; +} +pub fn msgpack_pack_int16(arg_x: [*c]msgpack_packer, arg_d: i16) callconv(.C) c_int { + var x = arg_x; + var d = arg_d; + while (true) { + if (@bitCast(c_int, @as(c_int, d)) < -(@as(c_int, 1) << @intCast(@import("std").math.Log2Int(c_int), 5))) { + if (@bitCast(c_int, @as(c_int, d)) < -(@as(c_int, 1) << @intCast(@import("std").math.Log2Int(c_int), 7))) { + var buf: [3]u8 = undefined; + buf[@intCast(c_uint, @as(c_int, 0))] = 209; + while (true) { + var val: u16 = ntohs(@bitCast(u16, d)); + _ = memcpy(@ptrCast(?*anyopaque, &buf[@intCast(c_uint, @as(c_int, 1))]), @ptrCast(?*const anyopaque, &val), @bitCast(c_ulong, @as(c_long, @as(c_int, 2)))); + if (!false) break; + } + return x.*.callback.?(x.*.data, @ptrCast([*c]const u8, @alignCast(@import("std").meta.alignment([*c]const u8), @ptrCast([*c]u8, @alignCast(@import("std").meta.alignment([*c]u8), &buf)))), @bitCast(usize, @as(c_long, @as(c_int, 3)))); + } else { + var buf: [2]u8 = [2]u8{ + 208, + @ptrCast([*c]u8, @alignCast(@import("std").meta.alignment([*c]u8), &d))[@intCast(c_uint, @as(c_int, 0))], + }; + return x.*.callback.?(x.*.data, @ptrCast([*c]const u8, @alignCast(@import("std").meta.alignment([*c]const u8), @ptrCast([*c]u8, @alignCast(@import("std").meta.alignment([*c]u8), &buf)))), @bitCast(usize, @as(c_long, @as(c_int, 2)))); + } + } else if (@bitCast(c_int, @as(c_int, d)) < (@as(c_int, 1) << @intCast(@import("std").math.Log2Int(c_int), 7))) { + return x.*.callback.?(x.*.data, @ptrCast([*c]const u8, @alignCast(@import("std").meta.alignment([*c]const u8), &@ptrCast([*c]u8, @alignCast(@import("std").meta.alignment([*c]u8), &d))[@intCast(c_uint, @as(c_int, 0))])), @bitCast(usize, @as(c_long, @as(c_int, 1)))); + } else { + if (@bitCast(c_int, @as(c_int, d)) < (@as(c_int, 1) << @intCast(@import("std").math.Log2Int(c_int), 8))) { + var buf: [2]u8 = [2]u8{ + 204, + @ptrCast([*c]u8, @alignCast(@import("std").meta.alignment([*c]u8), &d))[@intCast(c_uint, @as(c_int, 0))], + }; + return x.*.callback.?(x.*.data, @ptrCast([*c]const u8, @alignCast(@import("std").meta.alignment([*c]const u8), @ptrCast([*c]u8, @alignCast(@import("std").meta.alignment([*c]u8), &buf)))), @bitCast(usize, @as(c_long, @as(c_int, 2)))); + } else { + var buf: [3]u8 = undefined; + buf[@intCast(c_uint, @as(c_int, 0))] = 205; + while (true) { + var val: u16 = ntohs(@bitCast(u16, d)); + _ = memcpy(@ptrCast(?*anyopaque, &buf[@intCast(c_uint, @as(c_int, 1))]), @ptrCast(?*const anyopaque, &val), @bitCast(c_ulong, @as(c_long, @as(c_int, 2)))); + if (!false) break; + } + return x.*.callback.?(x.*.data, @ptrCast([*c]const u8, @alignCast(@import("std").meta.alignment([*c]const u8), @ptrCast([*c]u8, @alignCast(@import("std").meta.alignment([*c]u8), &buf)))), @bitCast(usize, @as(c_long, @as(c_int, 3)))); + } + } + if (!false) break; + } + return 0; +} +pub fn msgpack_pack_int32(arg_x: [*c]msgpack_packer, arg_d: i32) callconv(.C) c_int { + var x = arg_x; + var d = arg_d; + while (true) { + if (d < -(@as(c_int, 1) << @intCast(@import("std").math.Log2Int(c_int), 5))) { + if (d < -(@as(c_int, 1) << @intCast(@import("std").math.Log2Int(c_int), 15))) { + var buf: [5]u8 = undefined; + buf[@intCast(c_uint, @as(c_int, 0))] = 210; + while (true) { + var val: u32 = ntohl(@bitCast(u32, d)); + _ = memcpy(@ptrCast(?*anyopaque, &buf[@intCast(c_uint, @as(c_int, 1))]), @ptrCast(?*const anyopaque, &val), @bitCast(c_ulong, @as(c_long, @as(c_int, 4)))); + if (!false) break; + } + return x.*.callback.?(x.*.data, @ptrCast([*c]const u8, @alignCast(@import("std").meta.alignment([*c]const u8), @ptrCast([*c]u8, @alignCast(@import("std").meta.alignment([*c]u8), &buf)))), @bitCast(usize, @as(c_long, @as(c_int, 5)))); + } else if (d < -(@as(c_int, 1) << @intCast(@import("std").math.Log2Int(c_int), 7))) { + var buf: [3]u8 = undefined; + buf[@intCast(c_uint, @as(c_int, 0))] = 209; + while (true) { + var val: u16 = ntohs(@bitCast(u16, @bitCast(i16, @truncate(c_short, d)))); + _ = memcpy(@ptrCast(?*anyopaque, &buf[@intCast(c_uint, @as(c_int, 1))]), @ptrCast(?*const anyopaque, &val), @bitCast(c_ulong, @as(c_long, @as(c_int, 2)))); + if (!false) break; + } + return x.*.callback.?(x.*.data, @ptrCast([*c]const u8, @alignCast(@import("std").meta.alignment([*c]const u8), @ptrCast([*c]u8, @alignCast(@import("std").meta.alignment([*c]u8), &buf)))), @bitCast(usize, @as(c_long, @as(c_int, 3)))); + } else { + var buf: [2]u8 = [2]u8{ + 208, + @ptrCast([*c]u8, @alignCast(@import("std").meta.alignment([*c]u8), &d))[@intCast(c_uint, @as(c_int, 0))], + }; + return x.*.callback.?(x.*.data, @ptrCast([*c]const u8, @alignCast(@import("std").meta.alignment([*c]const u8), @ptrCast([*c]u8, @alignCast(@import("std").meta.alignment([*c]u8), &buf)))), @bitCast(usize, @as(c_long, @as(c_int, 2)))); + } + } else if (d < (@as(c_int, 1) << @intCast(@import("std").math.Log2Int(c_int), 7))) { + return x.*.callback.?(x.*.data, @ptrCast([*c]const u8, @alignCast(@import("std").meta.alignment([*c]const u8), &@ptrCast([*c]u8, @alignCast(@import("std").meta.alignment([*c]u8), &d))[@intCast(c_uint, @as(c_int, 0))])), @bitCast(usize, @as(c_long, @as(c_int, 1)))); + } else { + if (d < (@as(c_int, 1) << @intCast(@import("std").math.Log2Int(c_int), 8))) { + var buf: [2]u8 = [2]u8{ + 204, + @ptrCast([*c]u8, @alignCast(@import("std").meta.alignment([*c]u8), &d))[@intCast(c_uint, @as(c_int, 0))], + }; + return x.*.callback.?(x.*.data, @ptrCast([*c]const u8, @alignCast(@import("std").meta.alignment([*c]const u8), @ptrCast([*c]u8, @alignCast(@import("std").meta.alignment([*c]u8), &buf)))), @bitCast(usize, @as(c_long, @as(c_int, 2)))); + } else if (d < (@as(c_int, 1) << @intCast(@import("std").math.Log2Int(c_int), 16))) { + var buf: [3]u8 = undefined; + buf[@intCast(c_uint, @as(c_int, 0))] = 205; + while (true) { + var val: u16 = ntohs(@bitCast(u16, @truncate(c_short, d))); + _ = memcpy(@ptrCast(?*anyopaque, &buf[@intCast(c_uint, @as(c_int, 1))]), @ptrCast(?*const anyopaque, &val), @bitCast(c_ulong, @as(c_long, @as(c_int, 2)))); + if (!false) break; + } + return x.*.callback.?(x.*.data, @ptrCast([*c]const u8, @alignCast(@import("std").meta.alignment([*c]const u8), @ptrCast([*c]u8, @alignCast(@import("std").meta.alignment([*c]u8), &buf)))), @bitCast(usize, @as(c_long, @as(c_int, 3)))); + } else { + var buf: [5]u8 = undefined; + buf[@intCast(c_uint, @as(c_int, 0))] = 206; + while (true) { + var val: u32 = ntohl(@bitCast(u32, d)); + _ = memcpy(@ptrCast(?*anyopaque, &buf[@intCast(c_uint, @as(c_int, 1))]), @ptrCast(?*const anyopaque, &val), @bitCast(c_ulong, @as(c_long, @as(c_int, 4)))); + if (!false) break; + } + return x.*.callback.?(x.*.data, @ptrCast([*c]const u8, @alignCast(@import("std").meta.alignment([*c]const u8), @ptrCast([*c]u8, @alignCast(@import("std").meta.alignment([*c]u8), &buf)))), @bitCast(usize, @as(c_long, @as(c_int, 5)))); + } + } + if (!false) break; + } + return 0; +} +pub fn msgpack_pack_int64(arg_x: [*c]msgpack_packer, arg_d: i64) callconv(.C) c_int { + var x = arg_x; + var d = arg_d; + while (true) { + if (@bitCast(c_longlong, @as(c_longlong, d)) < -(@as(c_longlong, 1) << @intCast(@import("std").math.Log2Int(c_longlong), 5))) { + if (@bitCast(c_longlong, @as(c_longlong, d)) < -(@as(c_longlong, 1) << @intCast(@import("std").math.Log2Int(c_longlong), 15))) { + if (@bitCast(c_longlong, @as(c_longlong, d)) < -(@as(c_longlong, 1) << @intCast(@import("std").math.Log2Int(c_longlong), 31))) { + var buf: [9]u8 = undefined; + buf[@intCast(c_uint, @as(c_int, 0))] = 211; + while (true) { + var val: u64 = __bswap_64(@bitCast(__uint64_t, d)); + _ = memcpy(@ptrCast(?*anyopaque, &buf[@intCast(c_uint, @as(c_int, 1))]), @ptrCast(?*const anyopaque, &val), @bitCast(c_ulong, @as(c_long, @as(c_int, 8)))); + if (!false) break; + } + return x.*.callback.?(x.*.data, @ptrCast([*c]const u8, @alignCast(@import("std").meta.alignment([*c]const u8), @ptrCast([*c]u8, @alignCast(@import("std").meta.alignment([*c]u8), &buf)))), @bitCast(usize, @as(c_long, @as(c_int, 9)))); + } else { + var buf: [5]u8 = undefined; + buf[@intCast(c_uint, @as(c_int, 0))] = 210; + while (true) { + var val: u32 = ntohl(@bitCast(u32, @bitCast(i32, @truncate(c_int, d)))); + _ = memcpy(@ptrCast(?*anyopaque, &buf[@intCast(c_uint, @as(c_int, 1))]), @ptrCast(?*const anyopaque, &val), @bitCast(c_ulong, @as(c_long, @as(c_int, 4)))); + if (!false) break; + } + return x.*.callback.?(x.*.data, @ptrCast([*c]const u8, @alignCast(@import("std").meta.alignment([*c]const u8), @ptrCast([*c]u8, @alignCast(@import("std").meta.alignment([*c]u8), &buf)))), @bitCast(usize, @as(c_long, @as(c_int, 5)))); + } + } else { + if (d < @bitCast(i64, @as(c_long, -(@as(c_int, 1) << @intCast(@import("std").math.Log2Int(c_int), 7))))) { + var buf: [3]u8 = undefined; + buf[@intCast(c_uint, @as(c_int, 0))] = 209; + while (true) { + var val: u16 = ntohs(@bitCast(u16, @bitCast(i16, @truncate(c_short, d)))); + _ = memcpy(@ptrCast(?*anyopaque, &buf[@intCast(c_uint, @as(c_int, 1))]), @ptrCast(?*const anyopaque, &val), @bitCast(c_ulong, @as(c_long, @as(c_int, 2)))); + if (!false) break; + } + return x.*.callback.?(x.*.data, @ptrCast([*c]const u8, @alignCast(@import("std").meta.alignment([*c]const u8), @ptrCast([*c]u8, @alignCast(@import("std").meta.alignment([*c]u8), &buf)))), @bitCast(usize, @as(c_long, @as(c_int, 3)))); + } else { + var buf: [2]u8 = [2]u8{ + 208, + @ptrCast([*c]u8, @alignCast(@import("std").meta.alignment([*c]u8), &d))[@intCast(c_uint, @as(c_int, 0))], + }; + return x.*.callback.?(x.*.data, @ptrCast([*c]const u8, @alignCast(@import("std").meta.alignment([*c]const u8), @ptrCast([*c]u8, @alignCast(@import("std").meta.alignment([*c]u8), &buf)))), @bitCast(usize, @as(c_long, @as(c_int, 2)))); + } + } + } else if (d < @bitCast(i64, @as(c_long, @as(c_int, 1) << @intCast(@import("std").math.Log2Int(c_int), 7)))) { + return x.*.callback.?(x.*.data, @ptrCast([*c]const u8, @alignCast(@import("std").meta.alignment([*c]const u8), &@ptrCast([*c]u8, @alignCast(@import("std").meta.alignment([*c]u8), &d))[@intCast(c_uint, @as(c_int, 0))])), @bitCast(usize, @as(c_long, @as(c_int, 1)))); + } else { + if (@bitCast(c_longlong, @as(c_longlong, d)) < (@as(c_longlong, 1) << @intCast(@import("std").math.Log2Int(c_longlong), 16))) { + if (d < @bitCast(i64, @as(c_long, @as(c_int, 1) << @intCast(@import("std").math.Log2Int(c_int), 8)))) { + var buf: [2]u8 = [2]u8{ + 204, + @ptrCast([*c]u8, @alignCast(@import("std").meta.alignment([*c]u8), &d))[@intCast(c_uint, @as(c_int, 0))], + }; + return x.*.callback.?(x.*.data, @ptrCast([*c]const u8, @alignCast(@import("std").meta.alignment([*c]const u8), @ptrCast([*c]u8, @alignCast(@import("std").meta.alignment([*c]u8), &buf)))), @bitCast(usize, @as(c_long, @as(c_int, 2)))); + } else { + var buf: [3]u8 = undefined; + buf[@intCast(c_uint, @as(c_int, 0))] = 205; + while (true) { + var val: u16 = ntohs(@bitCast(u16, @truncate(c_short, d))); + _ = memcpy(@ptrCast(?*anyopaque, &buf[@intCast(c_uint, @as(c_int, 1))]), @ptrCast(?*const anyopaque, &val), @bitCast(c_ulong, @as(c_long, @as(c_int, 2)))); + if (!false) break; + } + return x.*.callback.?(x.*.data, @ptrCast([*c]const u8, @alignCast(@import("std").meta.alignment([*c]const u8), @ptrCast([*c]u8, @alignCast(@import("std").meta.alignment([*c]u8), &buf)))), @bitCast(usize, @as(c_long, @as(c_int, 3)))); + } + } else { + if (@bitCast(c_longlong, @as(c_longlong, d)) < (@as(c_longlong, 1) << @intCast(@import("std").math.Log2Int(c_longlong), 32))) { + var buf: [5]u8 = undefined; + buf[@intCast(c_uint, @as(c_int, 0))] = 206; + while (true) { + var val: u32 = ntohl(@bitCast(u32, @truncate(c_int, d))); + _ = memcpy(@ptrCast(?*anyopaque, &buf[@intCast(c_uint, @as(c_int, 1))]), @ptrCast(?*const anyopaque, &val), @bitCast(c_ulong, @as(c_long, @as(c_int, 4)))); + if (!false) break; + } + return x.*.callback.?(x.*.data, @ptrCast([*c]const u8, @alignCast(@import("std").meta.alignment([*c]const u8), @ptrCast([*c]u8, @alignCast(@import("std").meta.alignment([*c]u8), &buf)))), @bitCast(usize, @as(c_long, @as(c_int, 5)))); + } else { + var buf: [9]u8 = undefined; + buf[@intCast(c_uint, @as(c_int, 0))] = 207; + while (true) { + var val: u64 = __bswap_64(@bitCast(__uint64_t, d)); + _ = memcpy(@ptrCast(?*anyopaque, &buf[@intCast(c_uint, @as(c_int, 1))]), @ptrCast(?*const anyopaque, &val), @bitCast(c_ulong, @as(c_long, @as(c_int, 8)))); + if (!false) break; + } + return x.*.callback.?(x.*.data, @ptrCast([*c]const u8, @alignCast(@import("std").meta.alignment([*c]const u8), @ptrCast([*c]u8, @alignCast(@import("std").meta.alignment([*c]u8), &buf)))), @bitCast(usize, @as(c_long, @as(c_int, 9)))); + } + } + } + if (!false) break; + } + return 0; +} +pub fn msgpack_pack_fix_uint8(arg_x: [*c]msgpack_packer, arg_d: u8) callconv(.C) c_int { + var x = arg_x; + var d = arg_d; + var buf: [2]u8 = [2]u8{ + 204, + (&d)[@intCast(c_uint, @as(c_int, 0))], + }; + return x.*.callback.?(x.*.data, @ptrCast([*c]const u8, @alignCast(@import("std").meta.alignment([*c]const u8), @ptrCast([*c]u8, @alignCast(@import("std").meta.alignment([*c]u8), &buf)))), @bitCast(usize, @as(c_long, @as(c_int, 2)))); +} +pub fn msgpack_pack_fix_uint16(arg_x: [*c]msgpack_packer, arg_d: u16) callconv(.C) c_int { + var x = arg_x; + var d = arg_d; + var buf: [3]u8 = undefined; + buf[@intCast(c_uint, @as(c_int, 0))] = 205; + while (true) { + var val: u16 = ntohs(d); + _ = memcpy(@ptrCast(?*anyopaque, &buf[@intCast(c_uint, @as(c_int, 1))]), @ptrCast(?*const anyopaque, &val), @bitCast(c_ulong, @as(c_long, @as(c_int, 2)))); + if (!false) break; + } + return x.*.callback.?(x.*.data, @ptrCast([*c]const u8, @alignCast(@import("std").meta.alignment([*c]const u8), @ptrCast([*c]u8, @alignCast(@import("std").meta.alignment([*c]u8), &buf)))), @bitCast(usize, @as(c_long, @as(c_int, 3)))); +} +pub fn msgpack_pack_fix_uint32(arg_x: [*c]msgpack_packer, arg_d: u32) callconv(.C) c_int { + var x = arg_x; + var d = arg_d; + var buf: [5]u8 = undefined; + buf[@intCast(c_uint, @as(c_int, 0))] = 206; + while (true) { + var val: u32 = ntohl(d); + _ = memcpy(@ptrCast(?*anyopaque, &buf[@intCast(c_uint, @as(c_int, 1))]), @ptrCast(?*const anyopaque, &val), @bitCast(c_ulong, @as(c_long, @as(c_int, 4)))); + if (!false) break; + } + return x.*.callback.?(x.*.data, @ptrCast([*c]const u8, @alignCast(@import("std").meta.alignment([*c]const u8), @ptrCast([*c]u8, @alignCast(@import("std").meta.alignment([*c]u8), &buf)))), @bitCast(usize, @as(c_long, @as(c_int, 5)))); +} +pub fn msgpack_pack_fix_uint64(arg_x: [*c]msgpack_packer, arg_d: u64) callconv(.C) c_int { + var x = arg_x; + var d = arg_d; + var buf: [9]u8 = undefined; + buf[@intCast(c_uint, @as(c_int, 0))] = 207; + while (true) { + var val: u64 = __bswap_64(d); + _ = memcpy(@ptrCast(?*anyopaque, &buf[@intCast(c_uint, @as(c_int, 1))]), @ptrCast(?*const anyopaque, &val), @bitCast(c_ulong, @as(c_long, @as(c_int, 8)))); + if (!false) break; + } + return x.*.callback.?(x.*.data, @ptrCast([*c]const u8, @alignCast(@import("std").meta.alignment([*c]const u8), @ptrCast([*c]u8, @alignCast(@import("std").meta.alignment([*c]u8), &buf)))), @bitCast(usize, @as(c_long, @as(c_int, 9)))); +} +pub fn msgpack_pack_fix_int8(arg_x: [*c]msgpack_packer, arg_d: i8) callconv(.C) c_int { + var x = arg_x; + var d = arg_d; + var buf: [2]u8 = [2]u8{ + 208, + @ptrCast([*c]u8, @alignCast(@import("std").meta.alignment([*c]u8), &d))[@intCast(c_uint, @as(c_int, 0))], + }; + return x.*.callback.?(x.*.data, @ptrCast([*c]const u8, @alignCast(@import("std").meta.alignment([*c]const u8), @ptrCast([*c]u8, @alignCast(@import("std").meta.alignment([*c]u8), &buf)))), @bitCast(usize, @as(c_long, @as(c_int, 2)))); +} +pub fn msgpack_pack_fix_int16(arg_x: [*c]msgpack_packer, arg_d: i16) callconv(.C) c_int { + var x = arg_x; + var d = arg_d; + var buf: [3]u8 = undefined; + buf[@intCast(c_uint, @as(c_int, 0))] = 209; + while (true) { + var val: u16 = ntohs(@bitCast(u16, d)); + _ = memcpy(@ptrCast(?*anyopaque, &buf[@intCast(c_uint, @as(c_int, 1))]), @ptrCast(?*const anyopaque, &val), @bitCast(c_ulong, @as(c_long, @as(c_int, 2)))); + if (!false) break; + } + return x.*.callback.?(x.*.data, @ptrCast([*c]const u8, @alignCast(@import("std").meta.alignment([*c]const u8), @ptrCast([*c]u8, @alignCast(@import("std").meta.alignment([*c]u8), &buf)))), @bitCast(usize, @as(c_long, @as(c_int, 3)))); +} +pub fn msgpack_pack_fix_int32(arg_x: [*c]msgpack_packer, arg_d: i32) callconv(.C) c_int { + var x = arg_x; + var d = arg_d; + var buf: [5]u8 = undefined; + buf[@intCast(c_uint, @as(c_int, 0))] = 210; + while (true) { + var val: u32 = ntohl(@bitCast(u32, d)); + _ = memcpy(@ptrCast(?*anyopaque, &buf[@intCast(c_uint, @as(c_int, 1))]), @ptrCast(?*const anyopaque, &val), @bitCast(c_ulong, @as(c_long, @as(c_int, 4)))); + if (!false) break; + } + return x.*.callback.?(x.*.data, @ptrCast([*c]const u8, @alignCast(@import("std").meta.alignment([*c]const u8), @ptrCast([*c]u8, @alignCast(@import("std").meta.alignment([*c]u8), &buf)))), @bitCast(usize, @as(c_long, @as(c_int, 5)))); +} +pub fn msgpack_pack_fix_int64(arg_x: [*c]msgpack_packer, arg_d: i64) callconv(.C) c_int { + var x = arg_x; + var d = arg_d; + var buf: [9]u8 = undefined; + buf[@intCast(c_uint, @as(c_int, 0))] = 211; + while (true) { + var val: u64 = __bswap_64(@bitCast(__uint64_t, d)); + _ = memcpy(@ptrCast(?*anyopaque, &buf[@intCast(c_uint, @as(c_int, 1))]), @ptrCast(?*const anyopaque, &val), @bitCast(c_ulong, @as(c_long, @as(c_int, 8)))); + if (!false) break; + } + return x.*.callback.?(x.*.data, @ptrCast([*c]const u8, @alignCast(@import("std").meta.alignment([*c]const u8), @ptrCast([*c]u8, @alignCast(@import("std").meta.alignment([*c]u8), &buf)))), @bitCast(usize, @as(c_long, @as(c_int, 9)))); +} +pub fn msgpack_pack_float(arg_x: [*c]msgpack_packer, arg_d: f32) callconv(.C) c_int { + var x = arg_x; + var d = arg_d; + var buf: [5]u8 = undefined; + const union_unnamed_128 = extern union { + f: f32, + i: u32, + }; + _ = @TypeOf(union_unnamed_128); + var mem: union_unnamed_128 = undefined; + mem.f = d; + buf[@intCast(c_uint, @as(c_int, 0))] = 202; + while (true) { + var val: u32 = ntohl(mem.i); + _ = memcpy(@ptrCast(?*anyopaque, &buf[@intCast(c_uint, @as(c_int, 1))]), @ptrCast(?*const anyopaque, &val), @bitCast(c_ulong, @as(c_long, @as(c_int, 4)))); + if (!false) break; + } + return x.*.callback.?(x.*.data, @ptrCast([*c]const u8, @alignCast(@import("std").meta.alignment([*c]const u8), @ptrCast([*c]u8, @alignCast(@import("std").meta.alignment([*c]u8), &buf)))), @bitCast(usize, @as(c_long, @as(c_int, 5)))); +} +pub fn msgpack_pack_double(arg_x: [*c]msgpack_packer, arg_d: f64) callconv(.C) c_int { + var x = arg_x; + var d = arg_d; + var buf: [9]u8 = undefined; + const union_unnamed_129 = extern union { + f: f64, + i: u64, + }; + _ = @TypeOf(union_unnamed_129); + var mem: union_unnamed_129 = undefined; + mem.f = d; + buf[@intCast(c_uint, @as(c_int, 0))] = 203; + while (true) { + var val: u64 = __bswap_64(mem.i); + _ = memcpy(@ptrCast(?*anyopaque, &buf[@intCast(c_uint, @as(c_int, 1))]), @ptrCast(?*const anyopaque, &val), @bitCast(c_ulong, @as(c_long, @as(c_int, 8)))); + if (!false) break; + } + return x.*.callback.?(x.*.data, @ptrCast([*c]const u8, @alignCast(@import("std").meta.alignment([*c]const u8), @ptrCast([*c]u8, @alignCast(@import("std").meta.alignment([*c]u8), &buf)))), @bitCast(usize, @as(c_long, @as(c_int, 9)))); +} +pub fn msgpack_pack_nil(arg_x: [*c]msgpack_packer) callconv(.C) c_int { + var x = arg_x; + const d = struct { + const static: u8 = 192; + }; + return x.*.callback.?(x.*.data, @ptrCast([*c]const u8, @alignCast(@import("std").meta.alignment([*c]const u8), &d.static)), @bitCast(usize, @as(c_long, @as(c_int, 1)))); +} +pub fn msgpack_pack_true(arg_x: [*c]msgpack_packer) callconv(.C) c_int { + var x = arg_x; + const d = struct { + const static: u8 = 195; + }; + return x.*.callback.?(x.*.data, @ptrCast([*c]const u8, @alignCast(@import("std").meta.alignment([*c]const u8), &d.static)), @bitCast(usize, @as(c_long, @as(c_int, 1)))); +} +pub fn msgpack_pack_false(arg_x: [*c]msgpack_packer) callconv(.C) c_int { + var x = arg_x; + const d = struct { + const static: u8 = 194; + }; + return x.*.callback.?(x.*.data, @ptrCast([*c]const u8, @alignCast(@import("std").meta.alignment([*c]const u8), &d.static)), @bitCast(usize, @as(c_long, @as(c_int, 1)))); +} +pub fn msgpack_pack_array(arg_x: [*c]msgpack_packer, arg_n: usize) callconv(.C) c_int { + var x = arg_x; + var n = arg_n; + if (n < @bitCast(usize, @as(c_long, @as(c_int, 16)))) { + var d: u8 = @bitCast(u8, @truncate(i8, @as(c_int, 144) | @bitCast(c_int, @as(c_uint, @bitCast(u8, @truncate(u8, n)))))); + return x.*.callback.?(x.*.data, @ptrCast([*c]const u8, @alignCast(@import("std").meta.alignment([*c]const u8), &d)), @bitCast(usize, @as(c_long, @as(c_int, 1)))); + } else if (n < @bitCast(usize, @as(c_long, @as(c_int, 65536)))) { + var buf: [3]u8 = undefined; + buf[@intCast(c_uint, @as(c_int, 0))] = 220; + while (true) { + var val: u16 = ntohs(@bitCast(u16, @truncate(c_ushort, n))); + _ = memcpy(@ptrCast(?*anyopaque, &buf[@intCast(c_uint, @as(c_int, 1))]), @ptrCast(?*const anyopaque, &val), @bitCast(c_ulong, @as(c_long, @as(c_int, 2)))); + if (!false) break; + } + return x.*.callback.?(x.*.data, @ptrCast([*c]const u8, @alignCast(@import("std").meta.alignment([*c]const u8), @ptrCast([*c]u8, @alignCast(@import("std").meta.alignment([*c]u8), &buf)))), @bitCast(usize, @as(c_long, @as(c_int, 3)))); + } else { + var buf: [5]u8 = undefined; + buf[@intCast(c_uint, @as(c_int, 0))] = 221; + while (true) { + var val: u32 = ntohl(@bitCast(u32, @truncate(c_uint, n))); + _ = memcpy(@ptrCast(?*anyopaque, &buf[@intCast(c_uint, @as(c_int, 1))]), @ptrCast(?*const anyopaque, &val), @bitCast(c_ulong, @as(c_long, @as(c_int, 4)))); + if (!false) break; + } + return x.*.callback.?(x.*.data, @ptrCast([*c]const u8, @alignCast(@import("std").meta.alignment([*c]const u8), @ptrCast([*c]u8, @alignCast(@import("std").meta.alignment([*c]u8), &buf)))), @bitCast(usize, @as(c_long, @as(c_int, 5)))); + } + return 0; +} +pub fn msgpack_pack_map(arg_x: [*c]msgpack_packer, arg_n: usize) callconv(.C) c_int { + var x = arg_x; + var n = arg_n; + if (n < @bitCast(usize, @as(c_long, @as(c_int, 16)))) { + var d: u8 = @bitCast(u8, @truncate(i8, @as(c_int, 128) | @bitCast(c_int, @as(c_uint, @bitCast(u8, @truncate(u8, n)))))); + return x.*.callback.?(x.*.data, @ptrCast([*c]const u8, @alignCast(@import("std").meta.alignment([*c]const u8), &@ptrCast([*c]u8, @alignCast(@import("std").meta.alignment([*c]u8), &d))[@intCast(c_uint, @as(c_int, 0))])), @bitCast(usize, @as(c_long, @as(c_int, 1)))); + } else if (n < @bitCast(usize, @as(c_long, @as(c_int, 65536)))) { + var buf: [3]u8 = undefined; + buf[@intCast(c_uint, @as(c_int, 0))] = 222; + while (true) { + var val: u16 = ntohs(@bitCast(u16, @truncate(c_ushort, n))); + _ = memcpy(@ptrCast(?*anyopaque, &buf[@intCast(c_uint, @as(c_int, 1))]), @ptrCast(?*const anyopaque, &val), @bitCast(c_ulong, @as(c_long, @as(c_int, 2)))); + if (!false) break; + } + return x.*.callback.?(x.*.data, @ptrCast([*c]const u8, @alignCast(@import("std").meta.alignment([*c]const u8), @ptrCast([*c]u8, @alignCast(@import("std").meta.alignment([*c]u8), &buf)))), @bitCast(usize, @as(c_long, @as(c_int, 3)))); + } else { + var buf: [5]u8 = undefined; + buf[@intCast(c_uint, @as(c_int, 0))] = 223; + while (true) { + var val: u32 = ntohl(@bitCast(u32, @truncate(c_uint, n))); + _ = memcpy(@ptrCast(?*anyopaque, &buf[@intCast(c_uint, @as(c_int, 1))]), @ptrCast(?*const anyopaque, &val), @bitCast(c_ulong, @as(c_long, @as(c_int, 4)))); + if (!false) break; + } + return x.*.callback.?(x.*.data, @ptrCast([*c]const u8, @alignCast(@import("std").meta.alignment([*c]const u8), @ptrCast([*c]u8, @alignCast(@import("std").meta.alignment([*c]u8), &buf)))), @bitCast(usize, @as(c_long, @as(c_int, 5)))); + } + return 0; +} +pub fn msgpack_pack_str(arg_x: [*c]msgpack_packer, arg_l: usize) callconv(.C) c_int { + var x = arg_x; + var l = arg_l; + if (l < @bitCast(usize, @as(c_long, @as(c_int, 32)))) { + var d: u8 = @bitCast(u8, @truncate(i8, @as(c_int, 160) | @bitCast(c_int, @as(c_uint, @bitCast(u8, @truncate(u8, l)))))); + return x.*.callback.?(x.*.data, @ptrCast([*c]const u8, @alignCast(@import("std").meta.alignment([*c]const u8), &@ptrCast([*c]u8, @alignCast(@import("std").meta.alignment([*c]u8), &d))[@intCast(c_uint, @as(c_int, 0))])), @bitCast(usize, @as(c_long, @as(c_int, 1)))); + } else if (l < @bitCast(usize, @as(c_long, @as(c_int, 256)))) { + var buf: [2]u8 = undefined; + buf[@intCast(c_uint, @as(c_int, 0))] = 217; + buf[@intCast(c_uint, @as(c_int, 1))] = @bitCast(u8, @truncate(u8, l)); + return x.*.callback.?(x.*.data, @ptrCast([*c]const u8, @alignCast(@import("std").meta.alignment([*c]const u8), @ptrCast([*c]u8, @alignCast(@import("std").meta.alignment([*c]u8), &buf)))), @bitCast(usize, @as(c_long, @as(c_int, 2)))); + } else if (l < @bitCast(usize, @as(c_long, @as(c_int, 65536)))) { + var buf: [3]u8 = undefined; + buf[@intCast(c_uint, @as(c_int, 0))] = 218; + while (true) { + var val: u16 = ntohs(@bitCast(u16, @truncate(c_ushort, l))); + _ = memcpy(@ptrCast(?*anyopaque, &buf[@intCast(c_uint, @as(c_int, 1))]), @ptrCast(?*const anyopaque, &val), @bitCast(c_ulong, @as(c_long, @as(c_int, 2)))); + if (!false) break; + } + return x.*.callback.?(x.*.data, @ptrCast([*c]const u8, @alignCast(@import("std").meta.alignment([*c]const u8), @ptrCast([*c]u8, @alignCast(@import("std").meta.alignment([*c]u8), &buf)))), @bitCast(usize, @as(c_long, @as(c_int, 3)))); + } else { + var buf: [5]u8 = undefined; + buf[@intCast(c_uint, @as(c_int, 0))] = 219; + while (true) { + var val: u32 = ntohl(@bitCast(u32, @truncate(c_uint, l))); + _ = memcpy(@ptrCast(?*anyopaque, &buf[@intCast(c_uint, @as(c_int, 1))]), @ptrCast(?*const anyopaque, &val), @bitCast(c_ulong, @as(c_long, @as(c_int, 4)))); + if (!false) break; + } + return x.*.callback.?(x.*.data, @ptrCast([*c]const u8, @alignCast(@import("std").meta.alignment([*c]const u8), @ptrCast([*c]u8, @alignCast(@import("std").meta.alignment([*c]u8), &buf)))), @bitCast(usize, @as(c_long, @as(c_int, 5)))); + } + return 0; +} +pub fn msgpack_pack_str_body(arg_x: [*c]msgpack_packer, arg_b: ?*const anyopaque, arg_l: usize) callconv(.C) c_int { + var x = arg_x; + var b = arg_b; + var l = arg_l; + return x.*.callback.?(x.*.data, @ptrCast([*c]const u8, @alignCast(@import("std").meta.alignment([*c]const u8), @ptrCast([*c]const u8, @alignCast(@import("std").meta.alignment([*c]const u8), b)))), l); +} +pub fn msgpack_pack_str_with_body(arg_pk: [*c]msgpack_packer, arg_b: ?*const anyopaque, arg_l: usize) callconv(.C) c_int { + var pk = arg_pk; + var b = arg_b; + var l = arg_l; + var ret: c_int = msgpack_pack_str(pk, l); + if (ret != @as(c_int, 0)) { + return ret; + } + return msgpack_pack_str_body(pk, b, l); +} +pub fn msgpack_pack_v4raw(arg_x: [*c]msgpack_packer, arg_l: usize) callconv(.C) c_int { + var x = arg_x; + var l = arg_l; + if (l < @bitCast(usize, @as(c_long, @as(c_int, 32)))) { + var d: u8 = @bitCast(u8, @truncate(i8, @as(c_int, 160) | @bitCast(c_int, @as(c_uint, @bitCast(u8, @truncate(u8, l)))))); + return x.*.callback.?(x.*.data, @ptrCast([*c]const u8, @alignCast(@import("std").meta.alignment([*c]const u8), &@ptrCast([*c]u8, @alignCast(@import("std").meta.alignment([*c]u8), &d))[@intCast(c_uint, @as(c_int, 0))])), @bitCast(usize, @as(c_long, @as(c_int, 1)))); + } else if (l < @bitCast(usize, @as(c_long, @as(c_int, 65536)))) { + var buf: [3]u8 = undefined; + buf[@intCast(c_uint, @as(c_int, 0))] = 218; + while (true) { + var val: u16 = ntohs(@bitCast(u16, @truncate(c_ushort, l))); + _ = memcpy(@ptrCast(?*anyopaque, &buf[@intCast(c_uint, @as(c_int, 1))]), @ptrCast(?*const anyopaque, &val), @bitCast(c_ulong, @as(c_long, @as(c_int, 2)))); + if (!false) break; + } + return x.*.callback.?(x.*.data, @ptrCast([*c]const u8, @alignCast(@import("std").meta.alignment([*c]const u8), @ptrCast([*c]u8, @alignCast(@import("std").meta.alignment([*c]u8), &buf)))), @bitCast(usize, @as(c_long, @as(c_int, 3)))); + } else { + var buf: [5]u8 = undefined; + buf[@intCast(c_uint, @as(c_int, 0))] = 219; + while (true) { + var val: u32 = ntohl(@bitCast(u32, @truncate(c_uint, l))); + _ = memcpy(@ptrCast(?*anyopaque, &buf[@intCast(c_uint, @as(c_int, 1))]), @ptrCast(?*const anyopaque, &val), @bitCast(c_ulong, @as(c_long, @as(c_int, 4)))); + if (!false) break; + } + return x.*.callback.?(x.*.data, @ptrCast([*c]const u8, @alignCast(@import("std").meta.alignment([*c]const u8), @ptrCast([*c]u8, @alignCast(@import("std").meta.alignment([*c]u8), &buf)))), @bitCast(usize, @as(c_long, @as(c_int, 5)))); + } + return 0; +} +pub fn msgpack_pack_v4raw_body(arg_x: [*c]msgpack_packer, arg_b: ?*const anyopaque, arg_l: usize) callconv(.C) c_int { + var x = arg_x; + var b = arg_b; + var l = arg_l; + return x.*.callback.?(x.*.data, @ptrCast([*c]const u8, @alignCast(@import("std").meta.alignment([*c]const u8), @ptrCast([*c]const u8, @alignCast(@import("std").meta.alignment([*c]const u8), b)))), l); +} +pub fn msgpack_pack_bin(arg_x: [*c]msgpack_packer, arg_l: usize) callconv(.C) c_int { + var x = arg_x; + var l = arg_l; + if (l < @bitCast(usize, @as(c_long, @as(c_int, 256)))) { + var buf: [2]u8 = undefined; + buf[@intCast(c_uint, @as(c_int, 0))] = 196; + buf[@intCast(c_uint, @as(c_int, 1))] = @bitCast(u8, @truncate(u8, l)); + return x.*.callback.?(x.*.data, @ptrCast([*c]const u8, @alignCast(@import("std").meta.alignment([*c]const u8), @ptrCast([*c]u8, @alignCast(@import("std").meta.alignment([*c]u8), &buf)))), @bitCast(usize, @as(c_long, @as(c_int, 2)))); + } else if (l < @bitCast(usize, @as(c_long, @as(c_int, 65536)))) { + var buf: [3]u8 = undefined; + buf[@intCast(c_uint, @as(c_int, 0))] = 197; + while (true) { + var val: u16 = ntohs(@bitCast(u16, @truncate(c_ushort, l))); + _ = memcpy(@ptrCast(?*anyopaque, &buf[@intCast(c_uint, @as(c_int, 1))]), @ptrCast(?*const anyopaque, &val), @bitCast(c_ulong, @as(c_long, @as(c_int, 2)))); + if (!false) break; + } + return x.*.callback.?(x.*.data, @ptrCast([*c]const u8, @alignCast(@import("std").meta.alignment([*c]const u8), @ptrCast([*c]u8, @alignCast(@import("std").meta.alignment([*c]u8), &buf)))), @bitCast(usize, @as(c_long, @as(c_int, 3)))); + } else { + var buf: [5]u8 = undefined; + buf[@intCast(c_uint, @as(c_int, 0))] = 198; + while (true) { + var val: u32 = ntohl(@bitCast(u32, @truncate(c_uint, l))); + _ = memcpy(@ptrCast(?*anyopaque, &buf[@intCast(c_uint, @as(c_int, 1))]), @ptrCast(?*const anyopaque, &val), @bitCast(c_ulong, @as(c_long, @as(c_int, 4)))); + if (!false) break; + } + return x.*.callback.?(x.*.data, @ptrCast([*c]const u8, @alignCast(@import("std").meta.alignment([*c]const u8), @ptrCast([*c]u8, @alignCast(@import("std").meta.alignment([*c]u8), &buf)))), @bitCast(usize, @as(c_long, @as(c_int, 5)))); + } + return 0; +} +pub fn msgpack_pack_bin_body(arg_x: [*c]msgpack_packer, arg_b: ?*const anyopaque, arg_l: usize) callconv(.C) c_int { + var x = arg_x; + var b = arg_b; + var l = arg_l; + return x.*.callback.?(x.*.data, @ptrCast([*c]const u8, @alignCast(@import("std").meta.alignment([*c]const u8), @ptrCast([*c]const u8, @alignCast(@import("std").meta.alignment([*c]const u8), b)))), l); +} +pub fn msgpack_pack_bin_with_body(arg_pk: [*c]msgpack_packer, arg_b: ?*const anyopaque, arg_l: usize) callconv(.C) c_int { + var pk = arg_pk; + var b = arg_b; + var l = arg_l; + var ret: c_int = msgpack_pack_bin(pk, l); + if (ret != @as(c_int, 0)) { + return ret; + } + return msgpack_pack_bin_body(pk, b, l); +} +pub fn msgpack_pack_ext(arg_x: [*c]msgpack_packer, arg_l: usize, arg_type: i8) callconv(.C) c_int { + var x = arg_x; + var l = arg_l; + var @"type" = arg_type; + while (true) { + switch (l) { + @bitCast(usize, @as(c_long, @as(c_int, 1))) => { + { + var buf: [2]u8 = undefined; + buf[@intCast(c_uint, @as(c_int, 0))] = 212; + buf[@intCast(c_uint, @as(c_int, 1))] = @bitCast(u8, @"type"); + return x.*.callback.?(x.*.data, @ptrCast([*c]const u8, @alignCast(@import("std").meta.alignment([*c]const u8), @ptrCast([*c]u8, @alignCast(@import("std").meta.alignment([*c]u8), &buf)))), @bitCast(usize, @as(c_long, @as(c_int, 2)))); + } + }, + @bitCast(usize, @as(c_long, @as(c_int, 2))) => { + { + var buf: [2]u8 = undefined; + buf[@intCast(c_uint, @as(c_int, 0))] = 213; + buf[@intCast(c_uint, @as(c_int, 1))] = @bitCast(u8, @"type"); + return x.*.callback.?(x.*.data, @ptrCast([*c]const u8, @alignCast(@import("std").meta.alignment([*c]const u8), @ptrCast([*c]u8, @alignCast(@import("std").meta.alignment([*c]u8), &buf)))), @bitCast(usize, @as(c_long, @as(c_int, 2)))); + } + }, + @bitCast(usize, @as(c_long, @as(c_int, 4))) => { + { + var buf: [2]u8 = undefined; + buf[@intCast(c_uint, @as(c_int, 0))] = 214; + buf[@intCast(c_uint, @as(c_int, 1))] = @bitCast(u8, @"type"); + return x.*.callback.?(x.*.data, @ptrCast([*c]const u8, @alignCast(@import("std").meta.alignment([*c]const u8), @ptrCast([*c]u8, @alignCast(@import("std").meta.alignment([*c]u8), &buf)))), @bitCast(usize, @as(c_long, @as(c_int, 2)))); + } + }, + @bitCast(usize, @as(c_long, @as(c_int, 8))) => { + { + var buf: [2]u8 = undefined; + buf[@intCast(c_uint, @as(c_int, 0))] = 215; + buf[@intCast(c_uint, @as(c_int, 1))] = @bitCast(u8, @"type"); + return x.*.callback.?(x.*.data, @ptrCast([*c]const u8, @alignCast(@import("std").meta.alignment([*c]const u8), @ptrCast([*c]u8, @alignCast(@import("std").meta.alignment([*c]u8), &buf)))), @bitCast(usize, @as(c_long, @as(c_int, 2)))); + } + }, + @bitCast(usize, @as(c_long, @as(c_int, 16))) => { + { + var buf: [2]u8 = undefined; + buf[@intCast(c_uint, @as(c_int, 0))] = 216; + buf[@intCast(c_uint, @as(c_int, 1))] = @bitCast(u8, @"type"); + return x.*.callback.?(x.*.data, @ptrCast([*c]const u8, @alignCast(@import("std").meta.alignment([*c]const u8), @ptrCast([*c]u8, @alignCast(@import("std").meta.alignment([*c]u8), &buf)))), @bitCast(usize, @as(c_long, @as(c_int, 2)))); + } + }, + else => { + if (l < @bitCast(usize, @as(c_long, @as(c_int, 256)))) { + var buf: [3]u8 = undefined; + buf[@intCast(c_uint, @as(c_int, 0))] = 199; + buf[@intCast(c_uint, @as(c_int, 1))] = @bitCast(u8, @truncate(u8, l)); + buf[@intCast(c_uint, @as(c_int, 2))] = @bitCast(u8, @"type"); + return x.*.callback.?(x.*.data, @ptrCast([*c]const u8, @alignCast(@import("std").meta.alignment([*c]const u8), @ptrCast([*c]u8, @alignCast(@import("std").meta.alignment([*c]u8), &buf)))), @bitCast(usize, @as(c_long, @as(c_int, 3)))); + } else if (l < @bitCast(usize, @as(c_long, @as(c_int, 65536)))) { + var buf: [4]u8 = undefined; + buf[@intCast(c_uint, @as(c_int, 0))] = 200; + while (true) { + var val: u16 = ntohs(@bitCast(u16, @truncate(c_ushort, l))); + _ = memcpy(@ptrCast(?*anyopaque, &buf[@intCast(c_uint, @as(c_int, 1))]), @ptrCast(?*const anyopaque, &val), @bitCast(c_ulong, @as(c_long, @as(c_int, 2)))); + if (!false) break; + } + buf[@intCast(c_uint, @as(c_int, 3))] = @bitCast(u8, @"type"); + return x.*.callback.?(x.*.data, @ptrCast([*c]const u8, @alignCast(@import("std").meta.alignment([*c]const u8), @ptrCast([*c]u8, @alignCast(@import("std").meta.alignment([*c]u8), &buf)))), @bitCast(usize, @as(c_long, @as(c_int, 4)))); + } else { + var buf: [6]u8 = undefined; + buf[@intCast(c_uint, @as(c_int, 0))] = 201; + while (true) { + var val: u32 = ntohl(@bitCast(u32, @truncate(c_uint, l))); + _ = memcpy(@ptrCast(?*anyopaque, &buf[@intCast(c_uint, @as(c_int, 1))]), @ptrCast(?*const anyopaque, &val), @bitCast(c_ulong, @as(c_long, @as(c_int, 4)))); + if (!false) break; + } + buf[@intCast(c_uint, @as(c_int, 5))] = @bitCast(u8, @"type"); + return x.*.callback.?(x.*.data, @ptrCast([*c]const u8, @alignCast(@import("std").meta.alignment([*c]const u8), @ptrCast([*c]u8, @alignCast(@import("std").meta.alignment([*c]u8), &buf)))), @bitCast(usize, @as(c_long, @as(c_int, 6)))); + } + break; + }, + } + break; + } + return 0; +} +pub fn msgpack_pack_ext_body(arg_x: [*c]msgpack_packer, arg_b: ?*const anyopaque, arg_l: usize) callconv(.C) c_int { + var x = arg_x; + var b = arg_b; + var l = arg_l; + return x.*.callback.?(x.*.data, @ptrCast([*c]const u8, @alignCast(@import("std").meta.alignment([*c]const u8), @ptrCast([*c]const u8, @alignCast(@import("std").meta.alignment([*c]const u8), b)))), l); +} +pub fn msgpack_pack_ext_with_body(arg_pk: [*c]msgpack_packer, arg_b: ?*const anyopaque, arg_l: usize, arg_type: i8) callconv(.C) c_int { + var pk = arg_pk; + var b = arg_b; + var l = arg_l; + var @"type" = arg_type; + var ret: c_int = msgpack_pack_ext(pk, l, @"type"); + if (ret != @as(c_int, 0)) { + return ret; + } + return msgpack_pack_ext_body(pk, b, l); +} +pub fn msgpack_pack_timestamp(arg_x: [*c]msgpack_packer, arg_d: [*c]const msgpack_timestamp) callconv(.C) c_int { + var x = arg_x; + var d = arg_d; + if ((d.*.tv_sec >> @intCast(@import("std").math.Log2Int(i64), 34)) == @bitCast(i64, @as(c_long, @as(c_int, 0)))) { + var data64: u64 = (@bitCast(u64, @as(c_ulong, d.*.tv_nsec)) << @intCast(@import("std").math.Log2Int(u64), 34)) | @bitCast(u64, d.*.tv_sec); + if ((data64 & @as(c_ulong, 18446744069414584320)) == @bitCast(c_ulong, @as(c_long, @as(c_int, 0)))) { + var buf: [4]u8 = undefined; + var data32: u32 = @bitCast(u32, @truncate(c_uint, data64)); + _ = msgpack_pack_ext(x, @bitCast(usize, @as(c_long, @as(c_int, 4))), @bitCast(i8, @truncate(i8, -@as(c_int, 1)))); + while (true) { + var val: u32 = ntohl(data32); + _ = memcpy(@ptrCast(?*anyopaque, @ptrCast([*c]u8, @alignCast(@import("std").meta.alignment([*c]u8), &buf))), @ptrCast(?*const anyopaque, &val), @bitCast(c_ulong, @as(c_long, @as(c_int, 4)))); + if (!false) break; + } + return x.*.callback.?(x.*.data, @ptrCast([*c]const u8, @alignCast(@import("std").meta.alignment([*c]const u8), @ptrCast([*c]u8, @alignCast(@import("std").meta.alignment([*c]u8), &buf)))), @bitCast(usize, @as(c_long, @as(c_int, 4)))); + } else { + var buf: [8]u8 = undefined; + _ = msgpack_pack_ext(x, @bitCast(usize, @as(c_long, @as(c_int, 8))), @bitCast(i8, @truncate(i8, -@as(c_int, 1)))); + while (true) { + var val: u64 = __bswap_64(data64); + _ = memcpy(@ptrCast(?*anyopaque, @ptrCast([*c]u8, @alignCast(@import("std").meta.alignment([*c]u8), &buf))), @ptrCast(?*const anyopaque, &val), @bitCast(c_ulong, @as(c_long, @as(c_int, 8)))); + if (!false) break; + } + return x.*.callback.?(x.*.data, @ptrCast([*c]const u8, @alignCast(@import("std").meta.alignment([*c]const u8), @ptrCast([*c]u8, @alignCast(@import("std").meta.alignment([*c]u8), &buf)))), @bitCast(usize, @as(c_long, @as(c_int, 8)))); + } + } else { + var buf: [12]u8 = undefined; + while (true) { + var val: u32 = ntohl(d.*.tv_nsec); + _ = memcpy(@ptrCast(?*anyopaque, &buf[@intCast(c_uint, @as(c_int, 0))]), @ptrCast(?*const anyopaque, &val), @bitCast(c_ulong, @as(c_long, @as(c_int, 4)))); + if (!false) break; + } + while (true) { + var val: u64 = __bswap_64(@bitCast(__uint64_t, d.*.tv_sec)); + _ = memcpy(@ptrCast(?*anyopaque, &buf[@intCast(c_uint, @as(c_int, 4))]), @ptrCast(?*const anyopaque, &val), @bitCast(c_ulong, @as(c_long, @as(c_int, 8)))); + if (!false) break; + } + _ = msgpack_pack_ext(x, @bitCast(usize, @as(c_long, @as(c_int, 12))), @bitCast(i8, @truncate(i8, -@as(c_int, 1)))); + return x.*.callback.?(x.*.data, @ptrCast([*c]const u8, @alignCast(@import("std").meta.alignment([*c]const u8), @ptrCast([*c]u8, @alignCast(@import("std").meta.alignment([*c]u8), &buf)))), @bitCast(usize, @as(c_long, @as(c_int, 12)))); + } + return 0; +} +pub extern fn msgpack_pack_object(pk: [*c]msgpack_packer, d: msgpack_object) c_int; +pub const struct_msgpack_unpacked = extern struct { + zone: [*c]msgpack_zone, + data: msgpack_object, +}; +pub const msgpack_unpacked = struct_msgpack_unpacked; +pub const MSGPACK_UNPACK_SUCCESS: c_int = 2; +pub const MSGPACK_UNPACK_EXTRA_BYTES: c_int = 1; +pub const MSGPACK_UNPACK_CONTINUE: c_int = 0; +pub const MSGPACK_UNPACK_PARSE_ERROR: c_int = -1; +pub const MSGPACK_UNPACK_NOMEM_ERROR: c_int = -2; +pub const msgpack_unpack_return = c_int; +pub extern fn msgpack_unpack_next(result: [*c]msgpack_unpacked, data: [*c]const u8, len: usize, off: [*c]usize) msgpack_unpack_return; +pub const struct_msgpack_unpacker = extern struct { + buffer: [*c]u8, + used: usize, + free: usize, + off: usize, + parsed: usize, + z: [*c]msgpack_zone, + initial_buffer_size: usize, + ctx: ?*anyopaque, +}; +pub const msgpack_unpacker = struct_msgpack_unpacker; +pub extern fn msgpack_unpacker_init(mpac: [*c]msgpack_unpacker, initial_buffer_size: usize) bool; +pub extern fn msgpack_unpacker_destroy(mpac: [*c]msgpack_unpacker) void; +pub extern fn msgpack_unpacker_new(initial_buffer_size: usize) [*c]msgpack_unpacker; +pub extern fn msgpack_unpacker_free(mpac: [*c]msgpack_unpacker) void; +pub fn msgpack_unpacker_reserve_buffer(arg_mpac: [*c]msgpack_unpacker, arg_size: usize) callconv(.C) bool { + var mpac = arg_mpac; + var size = arg_size; + if (mpac.*.free >= size) { + return @as(c_int, 1) != 0; + } + return msgpack_unpacker_expand_buffer(mpac, size); +} +pub fn msgpack_unpacker_buffer(arg_mpac: [*c]msgpack_unpacker) callconv(.C) [*c]u8 { + var mpac = arg_mpac; + return mpac.*.buffer + mpac.*.used; +} +pub fn msgpack_unpacker_buffer_capacity(arg_mpac: [*c]const msgpack_unpacker) callconv(.C) usize { + var mpac = arg_mpac; + return mpac.*.free; +} +pub fn msgpack_unpacker_buffer_consumed(arg_mpac: [*c]msgpack_unpacker, arg_size: usize) callconv(.C) void { + var mpac = arg_mpac; + var size = arg_size; + mpac.*.used +%= size; + mpac.*.free -%= size; +} +pub extern fn msgpack_unpacker_next(mpac: [*c]msgpack_unpacker, pac: [*c]msgpack_unpacked) msgpack_unpack_return; +pub extern fn msgpack_unpacker_next_with_size(mpac: [*c]msgpack_unpacker, result: [*c]msgpack_unpacked, p_bytes: [*c]usize) msgpack_unpack_return; +pub fn msgpack_unpacked_init(arg_result: [*c]msgpack_unpacked) callconv(.C) void { + var result = arg_result; + _ = memset(@ptrCast(?*anyopaque, result), @as(c_int, 0), @sizeOf(msgpack_unpacked)); +} +pub fn msgpack_unpacked_destroy(arg_result: [*c]msgpack_unpacked) callconv(.C) void { + var result = arg_result; + if (result.*.zone != @ptrCast([*c]msgpack_zone, @alignCast(@import("std").meta.alignment([*c]msgpack_zone), @intToPtr(?*anyopaque, @as(c_int, 0))))) { + msgpack_zone_free(result.*.zone); + result.*.zone = null; + _ = memset(@ptrCast(?*anyopaque, &result.*.data), @as(c_int, 0), @sizeOf(msgpack_object)); + } +} +pub fn msgpack_unpacked_release_zone(arg_result: [*c]msgpack_unpacked) callconv(.C) [*c]msgpack_zone { + var result = arg_result; + if (result.*.zone != @ptrCast([*c]msgpack_zone, @alignCast(@import("std").meta.alignment([*c]msgpack_zone), @intToPtr(?*anyopaque, @as(c_int, 0))))) { + var z: [*c]msgpack_zone = result.*.zone; + result.*.zone = null; + return z; + } + return null; +} +pub extern fn msgpack_unpacker_execute(mpac: [*c]msgpack_unpacker) c_int; +pub extern fn msgpack_unpacker_data(mpac: [*c]msgpack_unpacker) msgpack_object; +pub extern fn msgpack_unpacker_release_zone(mpac: [*c]msgpack_unpacker) [*c]msgpack_zone; +pub extern fn msgpack_unpacker_reset_zone(mpac: [*c]msgpack_unpacker) void; +pub extern fn msgpack_unpacker_reset(mpac: [*c]msgpack_unpacker) void; +pub fn msgpack_unpacker_message_size(arg_mpac: [*c]const msgpack_unpacker) callconv(.C) usize { + var mpac = arg_mpac; + return (mpac.*.parsed -% mpac.*.off) +% mpac.*.used; +} +pub extern fn msgpack_unpack(data: [*c]const u8, len: usize, off: [*c]usize, result_zone: [*c]msgpack_zone, result: [*c]msgpack_object) msgpack_unpack_return; +pub fn msgpack_unpacker_parsed_size(arg_mpac: [*c]const msgpack_unpacker) callconv(.C) usize { + var mpac = arg_mpac; + return mpac.*.parsed; +} +pub extern fn msgpack_unpacker_flush_zone(mpac: [*c]msgpack_unpacker) bool; +pub extern fn msgpack_unpacker_expand_buffer(mpac: [*c]msgpack_unpacker, size: usize) bool; +pub const struct_msgpack_sbuffer = extern struct { + size: usize, + data: [*c]u8, + alloc: usize, +}; +pub const msgpack_sbuffer = struct_msgpack_sbuffer; +pub fn msgpack_sbuffer_init(arg_sbuf: [*c]msgpack_sbuffer) callconv(.C) void { + var sbuf = arg_sbuf; + _ = memset(@ptrCast(?*anyopaque, sbuf), @as(c_int, 0), @sizeOf(msgpack_sbuffer)); +} +pub fn msgpack_sbuffer_destroy(arg_sbuf: [*c]msgpack_sbuffer) callconv(.C) void { + var sbuf = arg_sbuf; + free(@ptrCast(?*anyopaque, sbuf.*.data)); +} +pub fn msgpack_sbuffer_new() callconv(.C) [*c]msgpack_sbuffer { + return @ptrCast([*c]msgpack_sbuffer, @alignCast(@import("std").meta.alignment([*c]msgpack_sbuffer), calloc(@bitCast(c_ulong, @as(c_long, @as(c_int, 1))), @sizeOf(msgpack_sbuffer)))); +} +pub fn msgpack_sbuffer_free(arg_sbuf: [*c]msgpack_sbuffer) callconv(.C) void { + var sbuf = arg_sbuf; + if (sbuf == @ptrCast([*c]msgpack_sbuffer, @alignCast(@import("std").meta.alignment([*c]msgpack_sbuffer), @intToPtr(?*anyopaque, @as(c_int, 0))))) { + return; + } + msgpack_sbuffer_destroy(sbuf); + free(@ptrCast(?*anyopaque, sbuf)); +} +pub fn msgpack_sbuffer_write(arg_data: ?*anyopaque, arg_buf: [*c]const u8, arg_len: usize) callconv(.C) c_int { + var data = arg_data; + var buf = arg_buf; + var len = arg_len; + var sbuf: [*c]msgpack_sbuffer = @ptrCast([*c]msgpack_sbuffer, @alignCast(@import("std").meta.alignment([*c]msgpack_sbuffer), data)); + _ = blk: { + _ = @sizeOf(c_int); + break :blk blk_1: { + break :blk_1 if ((buf != null) or (len == @bitCast(usize, @as(c_long, @as(c_int, 0))))) {} else { + __assert_fail("buf || len == 0", "/usr/include/msgpack/sbuffer.h", @bitCast(c_uint, @as(c_int, 64)), "int msgpack_sbuffer_write(void *, const char *, size_t)"); + }; + }; + }; + if (!(buf != null)) return 0; + if ((sbuf.*.alloc -% sbuf.*.size) < len) { + var tmp: ?*anyopaque = undefined; + var nsize: usize = if (sbuf.*.alloc != 0) sbuf.*.alloc *% @bitCast(usize, @as(c_long, @as(c_int, 2))) else @bitCast(usize, @as(c_long, @as(c_int, 8192))); + while (nsize < (sbuf.*.size +% len)) { + var tmp_nsize: usize = nsize *% @bitCast(usize, @as(c_long, @as(c_int, 2))); + if (tmp_nsize <= nsize) { + nsize = sbuf.*.size +% len; + break; + } + nsize = tmp_nsize; + } + tmp = realloc(@ptrCast(?*anyopaque, sbuf.*.data), nsize); + if (!(tmp != null)) { + return -@as(c_int, 1); + } + sbuf.*.data = @ptrCast([*c]u8, @alignCast(@import("std").meta.alignment([*c]u8), tmp)); + sbuf.*.alloc = nsize; + } + _ = memcpy(@ptrCast(?*anyopaque, sbuf.*.data + sbuf.*.size), @ptrCast(?*const anyopaque, buf), len); + sbuf.*.size +%= len; + return 0; +} +pub fn msgpack_sbuffer_release(arg_sbuf: [*c]msgpack_sbuffer) callconv(.C) [*c]u8 { + var sbuf = arg_sbuf; + var tmp: [*c]u8 = sbuf.*.data; + sbuf.*.size = 0; + sbuf.*.data = null; + sbuf.*.alloc = 0; + return tmp; +} +pub fn msgpack_sbuffer_clear(arg_sbuf: [*c]msgpack_sbuffer) callconv(.C) void { + var sbuf = arg_sbuf; + sbuf.*.size = 0; +} +pub extern fn readv(__fd: c_int, __iovec: [*c]const struct_iovec, __count: c_int) isize; +pub extern fn writev(__fd: c_int, __iovec: [*c]const struct_iovec, __count: c_int) isize; +pub extern fn preadv(__fd: c_int, __iovec: [*c]const struct_iovec, __count: c_int, __offset: __off_t) isize; +pub extern fn pwritev(__fd: c_int, __iovec: [*c]const struct_iovec, __count: c_int, __offset: __off_t) isize; +pub const msgpack_iovec = struct_iovec; +pub const struct_msgpack_vrefbuffer_chunk = opaque {}; +pub const msgpack_vrefbuffer_chunk = struct_msgpack_vrefbuffer_chunk; +pub const struct_msgpack_vrefbuffer_inner_buffer = extern struct { + free: usize, + ptr: [*c]u8, + head: ?*msgpack_vrefbuffer_chunk, +}; +pub const msgpack_vrefbuffer_inner_buffer = struct_msgpack_vrefbuffer_inner_buffer; +pub const struct_msgpack_vrefbuffer = extern struct { + tail: [*c]msgpack_iovec, + end: [*c]msgpack_iovec, + array: [*c]msgpack_iovec, + chunk_size: usize, + ref_size: usize, + inner_buffer: msgpack_vrefbuffer_inner_buffer, +}; +pub const msgpack_vrefbuffer = struct_msgpack_vrefbuffer; +pub extern fn msgpack_vrefbuffer_init(vbuf: [*c]msgpack_vrefbuffer, ref_size: usize, chunk_size: usize) bool; +pub extern fn msgpack_vrefbuffer_destroy(vbuf: [*c]msgpack_vrefbuffer) void; +pub fn msgpack_vrefbuffer_new(arg_ref_size: usize, arg_chunk_size: usize) callconv(.C) [*c]msgpack_vrefbuffer { + var ref_size = arg_ref_size; + var chunk_size = arg_chunk_size; + var vbuf: [*c]msgpack_vrefbuffer = @ptrCast([*c]msgpack_vrefbuffer, @alignCast(@import("std").meta.alignment([*c]msgpack_vrefbuffer), malloc(@sizeOf(msgpack_vrefbuffer)))); + if (vbuf == @ptrCast([*c]msgpack_vrefbuffer, @alignCast(@import("std").meta.alignment([*c]msgpack_vrefbuffer), @intToPtr(?*anyopaque, @as(c_int, 0))))) return null; + if (!msgpack_vrefbuffer_init(vbuf, ref_size, chunk_size)) { + free(@ptrCast(?*anyopaque, vbuf)); + return null; + } + return vbuf; +} +pub fn msgpack_vrefbuffer_free(arg_vbuf: [*c]msgpack_vrefbuffer) callconv(.C) void { + var vbuf = arg_vbuf; + if (vbuf == @ptrCast([*c]msgpack_vrefbuffer, @alignCast(@import("std").meta.alignment([*c]msgpack_vrefbuffer), @intToPtr(?*anyopaque, @as(c_int, 0))))) { + return; + } + msgpack_vrefbuffer_destroy(vbuf); + free(@ptrCast(?*anyopaque, vbuf)); +} +pub fn msgpack_vrefbuffer_write(arg_data: ?*anyopaque, arg_buf: [*c]const u8, arg_len: usize) callconv(.C) c_int { + var data = arg_data; + var buf = arg_buf; + var len = arg_len; + var vbuf: [*c]msgpack_vrefbuffer = @ptrCast([*c]msgpack_vrefbuffer, @alignCast(@import("std").meta.alignment([*c]msgpack_vrefbuffer), data)); + _ = blk: { + _ = @sizeOf(c_int); + break :blk blk_1: { + break :blk_1 if ((buf != null) or (len == @bitCast(usize, @as(c_long, @as(c_int, 0))))) {} else { + __assert_fail("buf || len == 0", "/usr/include/msgpack/vrefbuffer.h", @bitCast(c_uint, @as(c_int, 120)), "int msgpack_vrefbuffer_write(void *, const char *, size_t)"); + }; + }; + }; + if (!(buf != null)) return 0; + if (len < vbuf.*.ref_size) { + return msgpack_vrefbuffer_append_copy(vbuf, buf, len); + } else { + return msgpack_vrefbuffer_append_ref(vbuf, buf, len); + } + return 0; +} +pub fn msgpack_vrefbuffer_vec(arg_vref: [*c]const msgpack_vrefbuffer) callconv(.C) [*c]const msgpack_iovec { + var vref = arg_vref; + return vref.*.array; +} +pub fn msgpack_vrefbuffer_veclen(arg_vref: [*c]const msgpack_vrefbuffer) callconv(.C) usize { + var vref = arg_vref; + return @bitCast(usize, @divExact(@bitCast(c_long, @ptrToInt(vref.*.tail) -% @ptrToInt(vref.*.array)), @sizeOf(msgpack_iovec))); +} +pub extern fn msgpack_vrefbuffer_append_copy(vbuf: [*c]msgpack_vrefbuffer, buf: [*c]const u8, len: usize) c_int; +pub extern fn msgpack_vrefbuffer_append_ref(vbuf: [*c]msgpack_vrefbuffer, buf: [*c]const u8, len: usize) c_int; +pub extern fn msgpack_vrefbuffer_migrate(vbuf: [*c]msgpack_vrefbuffer, to: [*c]msgpack_vrefbuffer) c_int; +pub extern fn msgpack_vrefbuffer_clear(vref: [*c]msgpack_vrefbuffer) void; +pub extern fn msgpack_version() [*c]const u8; +pub extern fn msgpack_version_major() c_int; +pub extern fn msgpack_version_minor() c_int; +pub extern fn msgpack_version_revision() c_int; +pub const method_handlers: [*c]const MsgpackRpcRequestHandler = @extern([*c]const MsgpackRpcRequestHandler, .{ + .name = "method_handlers", +}); +pub extern fn msgpack_rpc_get_handler_for(name: [*c]const u8, name_len: usize, @"error": [*c]Error) MsgpackRpcRequestHandler; +pub extern fn context_hash(str: [*c]const u8, len: usize) c_int; +pub extern fn KeyDict_context_get_field(retval: ?*anyopaque, str: [*c]const u8, len: usize) [*c]Object; +pub extern fn set_decoration_provider_hash(str: [*c]const u8, len: usize) c_int; +pub extern fn KeyDict_set_decoration_provider_get_field(retval: ?*anyopaque, str: [*c]const u8, len: usize) [*c]Object; +pub extern fn set_extmark_hash(str: [*c]const u8, len: usize) c_int; +pub extern fn KeyDict_set_extmark_get_field(retval: ?*anyopaque, str: [*c]const u8, len: usize) [*c]Object; +pub extern fn keymap_hash(str: [*c]const u8, len: usize) c_int; +pub extern fn KeyDict_keymap_get_field(retval: ?*anyopaque, str: [*c]const u8, len: usize) [*c]Object; +pub extern fn get_commands_hash(str: [*c]const u8, len: usize) c_int; +pub extern fn KeyDict_get_commands_get_field(retval: ?*anyopaque, str: [*c]const u8, len: usize) [*c]Object; +pub extern fn user_command_hash(str: [*c]const u8, len: usize) c_int; +pub extern fn KeyDict_user_command_get_field(retval: ?*anyopaque, str: [*c]const u8, len: usize) [*c]Object; +pub extern fn float_config_hash(str: [*c]const u8, len: usize) c_int; +pub extern fn KeyDict_float_config_get_field(retval: ?*anyopaque, str: [*c]const u8, len: usize) [*c]Object; +pub extern fn runtime_hash(str: [*c]const u8, len: usize) c_int; +pub extern fn KeyDict_runtime_get_field(retval: ?*anyopaque, str: [*c]const u8, len: usize) [*c]Object; +pub extern fn eval_statusline_hash(str: [*c]const u8, len: usize) c_int; +pub extern fn KeyDict_eval_statusline_get_field(retval: ?*anyopaque, str: [*c]const u8, len: usize) [*c]Object; +pub extern fn option_hash(str: [*c]const u8, len: usize) c_int; +pub extern fn KeyDict_option_get_field(retval: ?*anyopaque, str: [*c]const u8, len: usize) [*c]Object; +pub extern fn highlight_hash(str: [*c]const u8, len: usize) c_int; +pub extern fn KeyDict_highlight_get_field(retval: ?*anyopaque, str: [*c]const u8, len: usize) [*c]Object; +pub extern fn highlight_cterm_hash(str: [*c]const u8, len: usize) c_int; +pub extern fn KeyDict_highlight_cterm_get_field(retval: ?*anyopaque, str: [*c]const u8, len: usize) [*c]Object; +pub extern fn get_highlight_hash(str: [*c]const u8, len: usize) c_int; +pub extern fn KeyDict_get_highlight_get_field(retval: ?*anyopaque, str: [*c]const u8, len: usize) [*c]Object; +pub extern fn clear_autocmds_hash(str: [*c]const u8, len: usize) c_int; +pub extern fn KeyDict_clear_autocmds_get_field(retval: ?*anyopaque, str: [*c]const u8, len: usize) [*c]Object; +pub extern fn create_autocmd_hash(str: [*c]const u8, len: usize) c_int; +pub extern fn KeyDict_create_autocmd_get_field(retval: ?*anyopaque, str: [*c]const u8, len: usize) [*c]Object; +pub extern fn exec_autocmds_hash(str: [*c]const u8, len: usize) c_int; +pub extern fn KeyDict_exec_autocmds_get_field(retval: ?*anyopaque, str: [*c]const u8, len: usize) [*c]Object; +pub extern fn get_autocmds_hash(str: [*c]const u8, len: usize) c_int; +pub extern fn KeyDict_get_autocmds_get_field(retval: ?*anyopaque, str: [*c]const u8, len: usize) [*c]Object; +pub extern fn create_augroup_hash(str: [*c]const u8, len: usize) c_int; +pub extern fn KeyDict_create_augroup_get_field(retval: ?*anyopaque, str: [*c]const u8, len: usize) [*c]Object; +pub extern fn cmd_hash(str: [*c]const u8, len: usize) c_int; +pub extern fn KeyDict_cmd_get_field(retval: ?*anyopaque, str: [*c]const u8, len: usize) [*c]Object; +pub extern fn cmd_magic_hash(str: [*c]const u8, len: usize) c_int; +pub extern fn KeyDict_cmd_magic_get_field(retval: ?*anyopaque, str: [*c]const u8, len: usize) [*c]Object; +pub extern fn cmd_mods_hash(str: [*c]const u8, len: usize) c_int; +pub extern fn KeyDict_cmd_mods_get_field(retval: ?*anyopaque, str: [*c]const u8, len: usize) [*c]Object; +pub extern fn cmd_mods_filter_hash(str: [*c]const u8, len: usize) c_int; +pub extern fn KeyDict_cmd_mods_filter_get_field(retval: ?*anyopaque, str: [*c]const u8, len: usize) [*c]Object; +pub extern fn cmd_opts_hash(str: [*c]const u8, len: usize) c_int; +pub extern fn KeyDict_cmd_opts_get_field(retval: ?*anyopaque, str: [*c]const u8, len: usize) [*c]Object; +pub extern fn echo_opts_hash(str: [*c]const u8, len: usize) c_int; +pub extern fn KeyDict_echo_opts_get_field(retval: ?*anyopaque, str: [*c]const u8, len: usize) [*c]Object; +pub extern fn exec_opts_hash(str: [*c]const u8, len: usize) c_int; +pub extern fn KeyDict_exec_opts_get_field(retval: ?*anyopaque, str: [*c]const u8, len: usize) [*c]Object; +pub extern fn handle_nvim_get_autocmds(channel_id: u64, args: Array, arena: [*c]Arena, @"error": [*c]Error) Object; +pub extern fn handle_nvim_create_autocmd(channel_id: u64, args: Array, arena: [*c]Arena, @"error": [*c]Error) Object; +pub extern fn handle_nvim_del_autocmd(channel_id: u64, args: Array, arena: [*c]Arena, @"error": [*c]Error) Object; +pub extern fn handle_nvim_clear_autocmds(channel_id: u64, args: Array, arena: [*c]Arena, @"error": [*c]Error) Object; +pub extern fn handle_nvim_create_augroup(channel_id: u64, args: Array, arena: [*c]Arena, @"error": [*c]Error) Object; +pub extern fn handle_nvim_del_augroup_by_id(channel_id: u64, args: Array, arena: [*c]Arena, @"error": [*c]Error) Object; +pub extern fn handle_nvim_del_augroup_by_name(channel_id: u64, args: Array, arena: [*c]Arena, @"error": [*c]Error) Object; +pub extern fn handle_nvim_exec_autocmds(channel_id: u64, args: Array, arena: [*c]Arena, @"error": [*c]Error) Object; +pub extern fn handle_nvim_buf_line_count(channel_id: u64, args: Array, arena: [*c]Arena, @"error": [*c]Error) Object; +pub extern fn handle_nvim_buf_attach(channel_id: u64, args: Array, arena: [*c]Arena, @"error": [*c]Error) Object; +pub extern fn handle_nvim_buf_detach(channel_id: u64, args: Array, arena: [*c]Arena, @"error": [*c]Error) Object; +pub extern fn handle_nvim__buf_redraw_range(channel_id: u64, args: Array, arena: [*c]Arena, @"error": [*c]Error) Object; +pub extern fn handle_nvim_buf_get_lines(channel_id: u64, args: Array, arena: [*c]Arena, @"error": [*c]Error) Object; +pub extern fn handle_nvim_buf_set_lines(channel_id: u64, args: Array, arena: [*c]Arena, @"error": [*c]Error) Object; +pub extern fn handle_nvim_buf_set_text(channel_id: u64, args: Array, arena: [*c]Arena, @"error": [*c]Error) Object; +pub extern fn handle_nvim_buf_get_text(channel_id: u64, args: Array, arena: [*c]Arena, @"error": [*c]Error) Object; +pub extern fn handle_nvim_buf_get_offset(channel_id: u64, args: Array, arena: [*c]Arena, @"error": [*c]Error) Object; +pub extern fn handle_nvim_buf_get_var(channel_id: u64, args: Array, arena: [*c]Arena, @"error": [*c]Error) Object; +pub extern fn handle_nvim_buf_get_changedtick(channel_id: u64, args: Array, arena: [*c]Arena, @"error": [*c]Error) Object; +pub extern fn handle_nvim_buf_get_keymap(channel_id: u64, args: Array, arena: [*c]Arena, @"error": [*c]Error) Object; +pub extern fn handle_nvim_buf_set_keymap(channel_id: u64, args: Array, arena: [*c]Arena, @"error": [*c]Error) Object; +pub extern fn handle_nvim_buf_del_keymap(channel_id: u64, args: Array, arena: [*c]Arena, @"error": [*c]Error) Object; +pub extern fn handle_nvim_buf_set_var(channel_id: u64, args: Array, arena: [*c]Arena, @"error": [*c]Error) Object; +pub extern fn handle_nvim_buf_del_var(channel_id: u64, args: Array, arena: [*c]Arena, @"error": [*c]Error) Object; +pub extern fn handle_nvim_buf_get_name(channel_id: u64, args: Array, arena: [*c]Arena, @"error": [*c]Error) Object; +pub extern fn handle_nvim_buf_set_name(channel_id: u64, args: Array, arena: [*c]Arena, @"error": [*c]Error) Object; +pub extern fn handle_nvim_buf_is_loaded(channel_id: u64, args: Array, arena: [*c]Arena, @"error": [*c]Error) Object; +pub extern fn handle_nvim_buf_delete(channel_id: u64, args: Array, arena: [*c]Arena, @"error": [*c]Error) Object; +pub extern fn handle_nvim_buf_is_valid(channel_id: u64, args: Array, arena: [*c]Arena, @"error": [*c]Error) Object; +pub extern fn handle_nvim_buf_del_mark(channel_id: u64, args: Array, arena: [*c]Arena, @"error": [*c]Error) Object; +pub extern fn handle_nvim_buf_set_mark(channel_id: u64, args: Array, arena: [*c]Arena, @"error": [*c]Error) Object; +pub extern fn handle_nvim_buf_get_mark(channel_id: u64, args: Array, arena: [*c]Arena, @"error": [*c]Error) Object; +pub extern fn handle_nvim__buf_stats(channel_id: u64, args: Array, arena: [*c]Arena, @"error": [*c]Error) Object; +pub extern fn handle_nvim_parse_cmd(channel_id: u64, args: Array, arena: [*c]Arena, @"error": [*c]Error) Object; +pub extern fn handle_nvim_cmd(channel_id: u64, args: Array, arena: [*c]Arena, @"error": [*c]Error) Object; +pub extern fn handle_nvim_create_user_command(channel_id: u64, args: Array, arena: [*c]Arena, @"error": [*c]Error) Object; +pub extern fn handle_nvim_del_user_command(channel_id: u64, args: Array, arena: [*c]Arena, @"error": [*c]Error) Object; +pub extern fn handle_nvim_buf_create_user_command(channel_id: u64, args: Array, arena: [*c]Arena, @"error": [*c]Error) Object; +pub extern fn handle_nvim_buf_del_user_command(channel_id: u64, args: Array, arena: [*c]Arena, @"error": [*c]Error) Object; +pub extern fn handle_nvim_get_commands(channel_id: u64, args: Array, arena: [*c]Arena, @"error": [*c]Error) Object; +pub extern fn handle_nvim_buf_get_commands(channel_id: u64, args: Array, arena: [*c]Arena, @"error": [*c]Error) Object; +pub extern fn handle_nvim_exec(channel_id: u64, args: Array, arena: [*c]Arena, @"error": [*c]Error) Object; +pub extern fn handle_nvim_command_output(channel_id: u64, args: Array, arena: [*c]Arena, @"error": [*c]Error) Object; +pub extern fn handle_nvim_execute_lua(channel_id: u64, args: Array, arena: [*c]Arena, @"error": [*c]Error) Object; +pub extern fn handle_nvim_buf_get_number(channel_id: u64, args: Array, arena: [*c]Arena, @"error": [*c]Error) Object; +pub extern fn handle_nvim_buf_clear_highlight(channel_id: u64, args: Array, arena: [*c]Arena, @"error": [*c]Error) Object; +pub extern fn handle_nvim_buf_set_virtual_text(channel_id: u64, args: Array, arena: [*c]Arena, @"error": [*c]Error) Object; +pub extern fn handle_nvim_get_hl_by_id(channel_id: u64, args: Array, arena: [*c]Arena, @"error": [*c]Error) Object; +pub extern fn handle_nvim_get_hl_by_name(channel_id: u64, args: Array, arena: [*c]Arena, @"error": [*c]Error) Object; +pub extern fn handle_buffer_insert(channel_id: u64, args: Array, arena: [*c]Arena, @"error": [*c]Error) Object; +pub extern fn handle_buffer_get_line(channel_id: u64, args: Array, arena: [*c]Arena, @"error": [*c]Error) Object; +pub extern fn handle_buffer_set_line(channel_id: u64, args: Array, arena: [*c]Arena, @"error": [*c]Error) Object; +pub extern fn handle_buffer_del_line(channel_id: u64, args: Array, arena: [*c]Arena, @"error": [*c]Error) Object; +pub extern fn handle_buffer_get_line_slice(channel_id: u64, args: Array, arena: [*c]Arena, @"error": [*c]Error) Object; +pub extern fn handle_buffer_set_line_slice(channel_id: u64, args: Array, arena: [*c]Arena, @"error": [*c]Error) Object; +pub extern fn handle_buffer_set_var(channel_id: u64, args: Array, arena: [*c]Arena, @"error": [*c]Error) Object; +pub extern fn handle_buffer_del_var(channel_id: u64, args: Array, arena: [*c]Arena, @"error": [*c]Error) Object; +pub extern fn handle_window_set_var(channel_id: u64, args: Array, arena: [*c]Arena, @"error": [*c]Error) Object; +pub extern fn handle_window_del_var(channel_id: u64, args: Array, arena: [*c]Arena, @"error": [*c]Error) Object; +pub extern fn handle_tabpage_set_var(channel_id: u64, args: Array, arena: [*c]Arena, @"error": [*c]Error) Object; +pub extern fn handle_tabpage_del_var(channel_id: u64, args: Array, arena: [*c]Arena, @"error": [*c]Error) Object; +pub extern fn handle_vim_set_var(channel_id: u64, args: Array, arena: [*c]Arena, @"error": [*c]Error) Object; +pub extern fn handle_vim_del_var(channel_id: u64, args: Array, arena: [*c]Arena, @"error": [*c]Error) Object; +pub extern fn handle_nvim_get_option_info(channel_id: u64, args: Array, arena: [*c]Arena, @"error": [*c]Error) Object; +pub extern fn handle_nvim_create_namespace(channel_id: u64, args: Array, arena: [*c]Arena, @"error": [*c]Error) Object; +pub extern fn handle_nvim_get_namespaces(channel_id: u64, args: Array, arena: [*c]Arena, @"error": [*c]Error) Object; +pub extern fn handle_nvim_buf_get_extmark_by_id(channel_id: u64, args: Array, arena: [*c]Arena, @"error": [*c]Error) Object; +pub extern fn handle_nvim_buf_get_extmarks(channel_id: u64, args: Array, arena: [*c]Arena, @"error": [*c]Error) Object; +pub extern fn handle_nvim_buf_set_extmark(channel_id: u64, args: Array, arena: [*c]Arena, @"error": [*c]Error) Object; +pub extern fn handle_nvim_buf_del_extmark(channel_id: u64, args: Array, arena: [*c]Arena, @"error": [*c]Error) Object; +pub extern fn handle_nvim_buf_add_highlight(channel_id: u64, args: Array, arena: [*c]Arena, @"error": [*c]Error) Object; +pub extern fn handle_nvim_buf_clear_namespace(channel_id: u64, args: Array, arena: [*c]Arena, @"error": [*c]Error) Object; +pub extern fn handle_nvim_get_option_value(channel_id: u64, args: Array, arena: [*c]Arena, @"error": [*c]Error) Object; +pub extern fn handle_nvim_set_option_value(channel_id: u64, args: Array, arena: [*c]Arena, @"error": [*c]Error) Object; +pub extern fn handle_nvim_get_all_options_info(channel_id: u64, args: Array, arena: [*c]Arena, @"error": [*c]Error) Object; +pub extern fn handle_nvim_get_option_info2(channel_id: u64, args: Array, arena: [*c]Arena, @"error": [*c]Error) Object; +pub extern fn handle_nvim_set_option(channel_id: u64, args: Array, arena: [*c]Arena, @"error": [*c]Error) Object; +pub extern fn handle_nvim_get_option(channel_id: u64, args: Array, arena: [*c]Arena, @"error": [*c]Error) Object; +pub extern fn handle_nvim_buf_get_option(channel_id: u64, args: Array, arena: [*c]Arena, @"error": [*c]Error) Object; +pub extern fn handle_nvim_buf_set_option(channel_id: u64, args: Array, arena: [*c]Arena, @"error": [*c]Error) Object; +pub extern fn handle_nvim_win_get_option(channel_id: u64, args: Array, arena: [*c]Arena, @"error": [*c]Error) Object; +pub extern fn handle_nvim_win_set_option(channel_id: u64, args: Array, arena: [*c]Arena, @"error": [*c]Error) Object; +pub extern fn handle_nvim_tabpage_list_wins(channel_id: u64, args: Array, arena: [*c]Arena, @"error": [*c]Error) Object; +pub extern fn handle_nvim_tabpage_get_var(channel_id: u64, args: Array, arena: [*c]Arena, @"error": [*c]Error) Object; +pub extern fn handle_nvim_tabpage_set_var(channel_id: u64, args: Array, arena: [*c]Arena, @"error": [*c]Error) Object; +pub extern fn handle_nvim_tabpage_del_var(channel_id: u64, args: Array, arena: [*c]Arena, @"error": [*c]Error) Object; +pub extern fn handle_nvim_tabpage_get_win(channel_id: u64, args: Array, arena: [*c]Arena, @"error": [*c]Error) Object; +pub extern fn handle_nvim_tabpage_get_number(channel_id: u64, args: Array, arena: [*c]Arena, @"error": [*c]Error) Object; +pub extern fn handle_nvim_tabpage_is_valid(channel_id: u64, args: Array, arena: [*c]Arena, @"error": [*c]Error) Object; +pub extern fn handle_nvim_ui_attach(channel_id: u64, args: Array, arena: [*c]Arena, @"error": [*c]Error) Object; +pub extern fn handle_ui_attach(channel_id: u64, args: Array, arena: [*c]Arena, @"error": [*c]Error) Object; +pub extern fn handle_nvim_ui_set_focus(channel_id: u64, args: Array, arena: [*c]Arena, @"error": [*c]Error) Object; +pub extern fn handle_nvim_ui_detach(channel_id: u64, args: Array, arena: [*c]Arena, @"error": [*c]Error) Object; +pub extern fn handle_nvim_ui_try_resize(channel_id: u64, args: Array, arena: [*c]Arena, @"error": [*c]Error) Object; +pub extern fn handle_nvim_ui_set_option(channel_id: u64, args: Array, arena: [*c]Arena, @"error": [*c]Error) Object; +pub extern fn handle_nvim_ui_try_resize_grid(channel_id: u64, args: Array, arena: [*c]Arena, @"error": [*c]Error) Object; +pub extern fn handle_nvim_ui_pum_set_height(channel_id: u64, args: Array, arena: [*c]Arena, @"error": [*c]Error) Object; +pub extern fn handle_nvim_ui_pum_set_bounds(channel_id: u64, args: Array, arena: [*c]Arena, @"error": [*c]Error) Object; +pub extern fn handle_nvim_get_hl_id_by_name(channel_id: u64, args: Array, arena: [*c]Arena, @"error": [*c]Error) Object; +pub extern fn handle_nvim_get_hl(channel_id: u64, args: Array, arena: [*c]Arena, @"error": [*c]Error) Object; +pub extern fn handle_nvim_set_hl(channel_id: u64, args: Array, arena: [*c]Arena, @"error": [*c]Error) Object; +pub extern fn handle_nvim_set_hl_ns(channel_id: u64, args: Array, arena: [*c]Arena, @"error": [*c]Error) Object; +pub extern fn handle_nvim_set_hl_ns_fast(channel_id: u64, args: Array, arena: [*c]Arena, @"error": [*c]Error) Object; +pub extern fn handle_nvim_feedkeys(channel_id: u64, args: Array, arena: [*c]Arena, @"error": [*c]Error) Object; +pub extern fn handle_nvim_input(channel_id: u64, args: Array, arena: [*c]Arena, @"error": [*c]Error) Object; +pub extern fn handle_nvim_input_mouse(channel_id: u64, args: Array, arena: [*c]Arena, @"error": [*c]Error) Object; +pub extern fn handle_nvim_replace_termcodes(channel_id: u64, args: Array, arena: [*c]Arena, @"error": [*c]Error) Object; +pub extern fn handle_nvim_exec_lua(channel_id: u64, args: Array, arena: [*c]Arena, @"error": [*c]Error) Object; +pub extern fn handle_nvim_notify(channel_id: u64, args: Array, arena: [*c]Arena, @"error": [*c]Error) Object; +pub extern fn handle_nvim_strwidth(channel_id: u64, args: Array, arena: [*c]Arena, @"error": [*c]Error) Object; +pub extern fn handle_nvim_list_runtime_paths(channel_id: u64, args: Array, arena: [*c]Arena, @"error": [*c]Error) Object; +pub extern fn handle_nvim__runtime_inspect(channel_id: u64, args: Array, arena: [*c]Arena, @"error": [*c]Error) Object; +pub extern fn handle_nvim_get_runtime_file(channel_id: u64, args: Array, arena: [*c]Arena, @"error": [*c]Error) Object; +pub extern fn handle_nvim__get_lib_dir(channel_id: u64, args: Array, arena: [*c]Arena, @"error": [*c]Error) Object; +pub extern fn handle_nvim__get_runtime(channel_id: u64, args: Array, arena: [*c]Arena, @"error": [*c]Error) Object; +pub extern fn handle_nvim_set_current_dir(channel_id: u64, args: Array, arena: [*c]Arena, @"error": [*c]Error) Object; +pub extern fn handle_nvim_get_current_line(channel_id: u64, args: Array, arena: [*c]Arena, @"error": [*c]Error) Object; +pub extern fn handle_nvim_set_current_line(channel_id: u64, args: Array, arena: [*c]Arena, @"error": [*c]Error) Object; +pub extern fn handle_nvim_del_current_line(channel_id: u64, args: Array, arena: [*c]Arena, @"error": [*c]Error) Object; +pub extern fn handle_nvim_get_var(channel_id: u64, args: Array, arena: [*c]Arena, @"error": [*c]Error) Object; +pub extern fn handle_nvim_set_var(channel_id: u64, args: Array, arena: [*c]Arena, @"error": [*c]Error) Object; +pub extern fn handle_nvim_del_var(channel_id: u64, args: Array, arena: [*c]Arena, @"error": [*c]Error) Object; +pub extern fn handle_nvim_get_vvar(channel_id: u64, args: Array, arena: [*c]Arena, @"error": [*c]Error) Object; +pub extern fn handle_nvim_set_vvar(channel_id: u64, args: Array, arena: [*c]Arena, @"error": [*c]Error) Object; +pub extern fn handle_nvim_echo(channel_id: u64, args: Array, arena: [*c]Arena, @"error": [*c]Error) Object; +pub extern fn handle_nvim_out_write(channel_id: u64, args: Array, arena: [*c]Arena, @"error": [*c]Error) Object; +pub extern fn handle_nvim_err_write(channel_id: u64, args: Array, arena: [*c]Arena, @"error": [*c]Error) Object; +pub extern fn handle_nvim_err_writeln(channel_id: u64, args: Array, arena: [*c]Arena, @"error": [*c]Error) Object; +pub extern fn handle_nvim_list_bufs(channel_id: u64, args: Array, arena: [*c]Arena, @"error": [*c]Error) Object; +pub extern fn handle_nvim_get_current_buf(channel_id: u64, args: Array, arena: [*c]Arena, @"error": [*c]Error) Object; +pub extern fn handle_nvim_set_current_buf(channel_id: u64, args: Array, arena: [*c]Arena, @"error": [*c]Error) Object; +pub extern fn handle_nvim_list_wins(channel_id: u64, args: Array, arena: [*c]Arena, @"error": [*c]Error) Object; +pub extern fn handle_nvim_get_current_win(channel_id: u64, args: Array, arena: [*c]Arena, @"error": [*c]Error) Object; +pub extern fn handle_nvim_set_current_win(channel_id: u64, args: Array, arena: [*c]Arena, @"error": [*c]Error) Object; +pub extern fn handle_nvim_create_buf(channel_id: u64, args: Array, arena: [*c]Arena, @"error": [*c]Error) Object; +pub extern fn handle_nvim_open_term(channel_id: u64, args: Array, arena: [*c]Arena, @"error": [*c]Error) Object; +pub extern fn handle_nvim_chan_send(channel_id: u64, args: Array, arena: [*c]Arena, @"error": [*c]Error) Object; +pub extern fn handle_nvim_list_tabpages(channel_id: u64, args: Array, arena: [*c]Arena, @"error": [*c]Error) Object; +pub extern fn handle_nvim_get_current_tabpage(channel_id: u64, args: Array, arena: [*c]Arena, @"error": [*c]Error) Object; +pub extern fn handle_nvim_set_current_tabpage(channel_id: u64, args: Array, arena: [*c]Arena, @"error": [*c]Error) Object; +pub extern fn handle_nvim_paste(channel_id: u64, args: Array, arena: [*c]Arena, @"error": [*c]Error) Object; +pub extern fn handle_nvim_put(channel_id: u64, args: Array, arena: [*c]Arena, @"error": [*c]Error) Object; +pub extern fn handle_nvim_subscribe(channel_id: u64, args: Array, arena: [*c]Arena, @"error": [*c]Error) Object; +pub extern fn handle_nvim_unsubscribe(channel_id: u64, args: Array, arena: [*c]Arena, @"error": [*c]Error) Object; +pub extern fn handle_nvim_get_color_by_name(channel_id: u64, args: Array, arena: [*c]Arena, @"error": [*c]Error) Object; +pub extern fn handle_nvim_get_color_map(channel_id: u64, args: Array, arena: [*c]Arena, @"error": [*c]Error) Object; +pub extern fn handle_nvim_get_context(channel_id: u64, args: Array, arena: [*c]Arena, @"error": [*c]Error) Object; +pub extern fn handle_nvim_load_context(channel_id: u64, args: Array, arena: [*c]Arena, @"error": [*c]Error) Object; +pub extern fn handle_nvim_get_mode(channel_id: u64, args: Array, arena: [*c]Arena, @"error": [*c]Error) Object; +pub extern fn handle_nvim_get_keymap(channel_id: u64, args: Array, arena: [*c]Arena, @"error": [*c]Error) Object; +pub extern fn handle_nvim_set_keymap(channel_id: u64, args: Array, arena: [*c]Arena, @"error": [*c]Error) Object; +pub extern fn handle_nvim_del_keymap(channel_id: u64, args: Array, arena: [*c]Arena, @"error": [*c]Error) Object; +pub extern fn handle_nvim_get_api_info(channel_id: u64, args: Array, arena: [*c]Arena, @"error": [*c]Error) Object; +pub extern fn handle_nvim_set_client_info(channel_id: u64, args: Array, arena: [*c]Arena, @"error": [*c]Error) Object; +pub extern fn handle_nvim_get_chan_info(channel_id: u64, args: Array, arena: [*c]Arena, @"error": [*c]Error) Object; +pub extern fn handle_nvim_list_chans(channel_id: u64, args: Array, arena: [*c]Arena, @"error": [*c]Error) Object; +pub extern fn handle_nvim_call_atomic(channel_id: u64, args: Array, arena: [*c]Arena, @"error": [*c]Error) Object; +pub extern fn handle_nvim__id(channel_id: u64, args: Array, arena: [*c]Arena, @"error": [*c]Error) Object; +pub extern fn handle_nvim__id_array(channel_id: u64, args: Array, arena: [*c]Arena, @"error": [*c]Error) Object; +pub extern fn handle_nvim__id_dictionary(channel_id: u64, args: Array, arena: [*c]Arena, @"error": [*c]Error) Object; +pub extern fn handle_nvim__id_float(channel_id: u64, args: Array, arena: [*c]Arena, @"error": [*c]Error) Object; +pub extern fn handle_nvim__stats(channel_id: u64, args: Array, arena: [*c]Arena, @"error": [*c]Error) Object; +pub extern fn handle_nvim_list_uis(channel_id: u64, args: Array, arena: [*c]Arena, @"error": [*c]Error) Object; +pub extern fn handle_nvim_get_proc_children(channel_id: u64, args: Array, arena: [*c]Arena, @"error": [*c]Error) Object; +pub extern fn handle_nvim_get_proc(channel_id: u64, args: Array, arena: [*c]Arena, @"error": [*c]Error) Object; +pub extern fn handle_nvim_select_popupmenu_item(channel_id: u64, args: Array, arena: [*c]Arena, @"error": [*c]Error) Object; +pub extern fn handle_nvim__inspect_cell(channel_id: u64, args: Array, arena: [*c]Arena, @"error": [*c]Error) Object; +pub extern fn handle_nvim__screenshot(channel_id: u64, args: Array, arena: [*c]Arena, @"error": [*c]Error) Object; +pub extern fn handle_nvim__unpack(channel_id: u64, args: Array, arena: [*c]Arena, @"error": [*c]Error) Object; +pub extern fn handle_nvim_del_mark(channel_id: u64, args: Array, arena: [*c]Arena, @"error": [*c]Error) Object; +pub extern fn handle_nvim_get_mark(channel_id: u64, args: Array, arena: [*c]Arena, @"error": [*c]Error) Object; +pub extern fn handle_nvim_eval_statusline(channel_id: u64, args: Array, arena: [*c]Arena, @"error": [*c]Error) Object; +pub extern fn handle_nvim_error_event(channel_id: u64, args: Array, arena: [*c]Arena, @"error": [*c]Error) Object; +pub extern fn handle_nvim_exec2(channel_id: u64, args: Array, arena: [*c]Arena, @"error": [*c]Error) Object; +pub extern fn handle_nvim_command(channel_id: u64, args: Array, arena: [*c]Arena, @"error": [*c]Error) Object; +pub extern fn handle_nvim_eval(channel_id: u64, args: Array, arena: [*c]Arena, @"error": [*c]Error) Object; +pub extern fn handle_nvim_call_function(channel_id: u64, args: Array, arena: [*c]Arena, @"error": [*c]Error) Object; +pub extern fn handle_nvim_call_dict_function(channel_id: u64, args: Array, arena: [*c]Arena, @"error": [*c]Error) Object; +pub extern fn handle_nvim_parse_expression(channel_id: u64, args: Array, arena: [*c]Arena, @"error": [*c]Error) Object; +pub extern fn handle_nvim_open_win(channel_id: u64, args: Array, arena: [*c]Arena, @"error": [*c]Error) Object; +pub extern fn handle_nvim_win_set_config(channel_id: u64, args: Array, arena: [*c]Arena, @"error": [*c]Error) Object; +pub extern fn handle_nvim_win_get_config(channel_id: u64, args: Array, arena: [*c]Arena, @"error": [*c]Error) Object; +pub extern fn handle_nvim_win_get_buf(channel_id: u64, args: Array, arena: [*c]Arena, @"error": [*c]Error) Object; +pub extern fn handle_nvim_win_set_buf(channel_id: u64, args: Array, arena: [*c]Arena, @"error": [*c]Error) Object; +pub extern fn handle_nvim_win_get_cursor(channel_id: u64, args: Array, arena: [*c]Arena, @"error": [*c]Error) Object; +pub extern fn handle_nvim_win_set_cursor(channel_id: u64, args: Array, arena: [*c]Arena, @"error": [*c]Error) Object; +pub extern fn handle_nvim_win_get_height(channel_id: u64, args: Array, arena: [*c]Arena, @"error": [*c]Error) Object; +pub extern fn handle_nvim_win_set_height(channel_id: u64, args: Array, arena: [*c]Arena, @"error": [*c]Error) Object; +pub extern fn handle_nvim_win_get_width(channel_id: u64, args: Array, arena: [*c]Arena, @"error": [*c]Error) Object; +pub extern fn handle_nvim_win_set_width(channel_id: u64, args: Array, arena: [*c]Arena, @"error": [*c]Error) Object; +pub extern fn handle_nvim_win_get_var(channel_id: u64, args: Array, arena: [*c]Arena, @"error": [*c]Error) Object; +pub extern fn handle_nvim_win_set_var(channel_id: u64, args: Array, arena: [*c]Arena, @"error": [*c]Error) Object; +pub extern fn handle_nvim_win_del_var(channel_id: u64, args: Array, arena: [*c]Arena, @"error": [*c]Error) Object; +pub extern fn handle_nvim_win_get_position(channel_id: u64, args: Array, arena: [*c]Arena, @"error": [*c]Error) Object; +pub extern fn handle_nvim_win_get_tabpage(channel_id: u64, args: Array, arena: [*c]Arena, @"error": [*c]Error) Object; +pub extern fn handle_nvim_win_get_number(channel_id: u64, args: Array, arena: [*c]Arena, @"error": [*c]Error) Object; +pub extern fn handle_nvim_win_is_valid(channel_id: u64, args: Array, arena: [*c]Arena, @"error": [*c]Error) Object; +pub extern fn handle_nvim_win_hide(channel_id: u64, args: Array, arena: [*c]Arena, @"error": [*c]Error) Object; +pub extern fn handle_nvim_win_close(channel_id: u64, args: Array, arena: [*c]Arena, @"error": [*c]Error) Object; +pub extern fn handle_nvim_win_set_hl_ns(channel_id: u64, args: Array, arena: [*c]Arena, @"error": [*c]Error) Object; +pub extern fn msgpack_rpc_get_handler_for_hash(str: [*c]const u8, len: usize) c_int; +pub const context_table: [*c]KeySetLink = @extern([*c]KeySetLink, .{ + .name = "context_table", +}); +pub const set_decoration_provider_table: [*c]KeySetLink = @extern([*c]KeySetLink, .{ + .name = "set_decoration_provider_table", +}); +pub const set_extmark_table: [*c]KeySetLink = @extern([*c]KeySetLink, .{ + .name = "set_extmark_table", +}); +pub const keymap_table: [*c]KeySetLink = @extern([*c]KeySetLink, .{ + .name = "keymap_table", +}); +pub const get_commands_table: [*c]KeySetLink = @extern([*c]KeySetLink, .{ + .name = "get_commands_table", +}); +pub const user_command_table: [*c]KeySetLink = @extern([*c]KeySetLink, .{ + .name = "user_command_table", +}); +pub const float_config_table: [*c]KeySetLink = @extern([*c]KeySetLink, .{ + .name = "float_config_table", +}); +pub const runtime_table: [*c]KeySetLink = @extern([*c]KeySetLink, .{ + .name = "runtime_table", +}); +pub const eval_statusline_table: [*c]KeySetLink = @extern([*c]KeySetLink, .{ + .name = "eval_statusline_table", +}); +pub const option_table: [*c]KeySetLink = @extern([*c]KeySetLink, .{ + .name = "option_table", +}); +pub const highlight_table: [*c]KeySetLink = @extern([*c]KeySetLink, .{ + .name = "highlight_table", +}); +pub const highlight_cterm_table: [*c]KeySetLink = @extern([*c]KeySetLink, .{ + .name = "highlight_cterm_table", +}); +pub const get_highlight_table: [*c]KeySetLink = @extern([*c]KeySetLink, .{ + .name = "get_highlight_table", +}); +pub const clear_autocmds_table: [*c]KeySetLink = @extern([*c]KeySetLink, .{ + .name = "clear_autocmds_table", +}); +pub const create_autocmd_table: [*c]KeySetLink = @extern([*c]KeySetLink, .{ + .name = "create_autocmd_table", +}); +pub const exec_autocmds_table: [*c]KeySetLink = @extern([*c]KeySetLink, .{ + .name = "exec_autocmds_table", +}); +pub const get_autocmds_table: [*c]KeySetLink = @extern([*c]KeySetLink, .{ + .name = "get_autocmds_table", +}); +pub const create_augroup_table: [*c]KeySetLink = @extern([*c]KeySetLink, .{ + .name = "create_augroup_table", +}); +pub const cmd_table: [*c]KeySetLink = @extern([*c]KeySetLink, .{ + .name = "cmd_table", +}); +pub const cmd_magic_table: [*c]KeySetLink = @extern([*c]KeySetLink, .{ + .name = "cmd_magic_table", +}); +pub const cmd_mods_table: [*c]KeySetLink = @extern([*c]KeySetLink, .{ + .name = "cmd_mods_table", +}); +pub const cmd_mods_filter_table: [*c]KeySetLink = @extern([*c]KeySetLink, .{ + .name = "cmd_mods_filter_table", +}); +pub const cmd_opts_table: [*c]KeySetLink = @extern([*c]KeySetLink, .{ + .name = "cmd_opts_table", +}); +pub const echo_opts_table: [*c]KeySetLink = @extern([*c]KeySetLink, .{ + .name = "echo_opts_table", +}); +pub const exec_opts_table: [*c]KeySetLink = @extern([*c]KeySetLink, .{ + .name = "exec_opts_table", +}); +pub const NUMBUFLEN: c_int = 65; +const enum_unnamed_130 = c_uint; +pub fn strappend(dst: [*c]u8, src: [*c]const u8) callconv(.C) [*c]u8 { + const src_len: usize = strlen(src); + return @ptrCast([*c]u8, @alignCast(@import("std").meta.alignment([*c]u8), memmove(@ptrCast(?*anyopaque, dst), @ptrCast(?*const anyopaque, src), src_len))) + src_len; +} +pub const StringBuilder = extern struct { + size: usize, + capacity: usize, + items: [*c]u8, +}; +pub extern fn xstrnsave(string: [*c]const u8, len: usize) [*c]u8; +pub extern fn vim_strsave_escaped(string: [*c]const u8, esc_chars: [*c]const u8) [*c]u8; +pub extern fn vim_strsave_escaped_ext(string: [*c]const u8, esc_chars: [*c]const u8, cc: u8, bsl: bool) [*c]u8; +pub extern fn vim_strnsave_unquoted(string: [*c]const u8, length: usize) [*c]u8; +pub extern fn vim_strsave_shellescape(string: [*c]const u8, do_special: bool, do_newline: bool) [*c]u8; +pub extern fn vim_strsave_up(string: [*c]const u8) [*c]u8; +pub extern fn vim_strnsave_up(string: [*c]const u8, len: usize) [*c]u8; +pub extern fn vim_strup(p: [*c]u8) void; +pub extern fn strcase_save(orig: [*c]const u8, upper: bool) [*c]u8; +pub extern fn del_trailing_spaces(ptr: [*c]u8) void; +pub extern fn vim_strchr(string: [*c]const u8, c: c_int) [*c]u8; +pub extern fn sort_strings(files: [*c][*c]u8, count: c_int) void; +pub extern fn has_non_ascii(s: [*c]const u8) bool; +pub extern fn has_non_ascii_len(s: [*c]const u8, len: usize) bool; +pub extern fn concat_str(noalias str1: [*c]const u8, noalias str2: [*c]const u8) [*c]u8; +pub extern fn vim_snprintf_add(str: [*c]u8, str_m: usize, fmt: [*c]const u8, ...) c_int; +pub extern fn vim_snprintf(str: [*c]u8, str_m: usize, fmt: [*c]const u8, ...) c_int; +pub extern fn vim_vsnprintf(str: [*c]u8, str_m: usize, fmt: [*c]const u8, ap: [*c]struct___va_list_tag) c_int; +pub extern fn vim_vsnprintf_typval(str: [*c]u8, str_m: usize, fmt: [*c]const u8, ap: [*c]struct___va_list_tag, tvs: [*c]typval_T) c_int; +pub extern fn kv_do_printf(str: [*c]StringBuilder, fmt: [*c]const u8, ...) c_int; +pub extern fn reverse_text(s: [*c]u8) [*c]u8; +pub extern fn strrep(src: [*c]const u8, what: [*c]const u8, rep: [*c]const u8) [*c]u8; +pub const KE_S_UP: c_int = 4; +pub const KE_S_DOWN: c_int = 5; +pub const KE_S_F1: c_int = 6; +pub const KE_S_F2: c_int = 7; +pub const KE_S_F3: c_int = 8; +pub const KE_S_F4: c_int = 9; +pub const KE_S_F5: c_int = 10; +pub const KE_S_F6: c_int = 11; +pub const KE_S_F7: c_int = 12; +pub const KE_S_F8: c_int = 13; +pub const KE_S_F9: c_int = 14; +pub const KE_S_F10: c_int = 15; +pub const KE_S_F11: c_int = 16; +pub const KE_S_F12: c_int = 17; +pub const KE_S_F13: c_int = 18; +pub const KE_S_F14: c_int = 19; +pub const KE_S_F15: c_int = 20; +pub const KE_S_F16: c_int = 21; +pub const KE_S_F17: c_int = 22; +pub const KE_S_F18: c_int = 23; +pub const KE_S_F19: c_int = 24; +pub const KE_S_F20: c_int = 25; +pub const KE_S_F21: c_int = 26; +pub const KE_S_F22: c_int = 27; +pub const KE_S_F23: c_int = 28; +pub const KE_S_F24: c_int = 29; +pub const KE_S_F25: c_int = 30; +pub const KE_S_F26: c_int = 31; +pub const KE_S_F27: c_int = 32; +pub const KE_S_F28: c_int = 33; +pub const KE_S_F29: c_int = 34; +pub const KE_S_F30: c_int = 35; +pub const KE_S_F31: c_int = 36; +pub const KE_S_F32: c_int = 37; +pub const KE_S_F33: c_int = 38; +pub const KE_S_F34: c_int = 39; +pub const KE_S_F35: c_int = 40; +pub const KE_S_F36: c_int = 41; +pub const KE_S_F37: c_int = 42; +pub const KE_MOUSE: c_int = 43; +pub const KE_LEFTMOUSE: c_int = 44; +pub const KE_LEFTDRAG: c_int = 45; +pub const KE_LEFTRELEASE: c_int = 46; +pub const KE_MIDDLEMOUSE: c_int = 47; +pub const KE_MIDDLEDRAG: c_int = 48; +pub const KE_MIDDLERELEASE: c_int = 49; +pub const KE_RIGHTMOUSE: c_int = 50; +pub const KE_RIGHTDRAG: c_int = 51; +pub const KE_RIGHTRELEASE: c_int = 52; +pub const KE_IGNORE: c_int = 53; +pub const KE_TAB: c_int = 54; +pub const KE_S_TAB_OLD: c_int = 55; +pub const KE_XF1: c_int = 57; +pub const KE_XF2: c_int = 58; +pub const KE_XF3: c_int = 59; +pub const KE_XF4: c_int = 60; +pub const KE_XEND: c_int = 61; +pub const KE_ZEND: c_int = 62; +pub const KE_XHOME: c_int = 63; +pub const KE_ZHOME: c_int = 64; +pub const KE_XUP: c_int = 65; +pub const KE_XDOWN: c_int = 66; +pub const KE_XLEFT: c_int = 67; +pub const KE_XRIGHT: c_int = 68; +pub const KE_LEFTMOUSE_NM: c_int = 69; +pub const KE_LEFTRELEASE_NM: c_int = 70; +pub const KE_S_XF1: c_int = 71; +pub const KE_S_XF2: c_int = 72; +pub const KE_S_XF3: c_int = 73; +pub const KE_S_XF4: c_int = 74; +pub const KE_MOUSEDOWN: c_int = 75; +pub const KE_MOUSEUP: c_int = 76; +pub const KE_MOUSELEFT: c_int = 77; +pub const KE_MOUSERIGHT: c_int = 78; +pub const KE_KINS: c_int = 79; +pub const KE_KDEL: c_int = 80; +pub const KE_SNR: c_int = 82; +pub const KE_PLUG: c_int = 83; +pub const KE_CMDWIN: c_int = 84; +pub const KE_C_LEFT: c_int = 85; +pub const KE_C_RIGHT: c_int = 86; +pub const KE_C_HOME: c_int = 87; +pub const KE_C_END: c_int = 88; +pub const KE_X1MOUSE: c_int = 89; +pub const KE_X1DRAG: c_int = 90; +pub const KE_X1RELEASE: c_int = 91; +pub const KE_X2MOUSE: c_int = 92; +pub const KE_X2DRAG: c_int = 93; +pub const KE_X2RELEASE: c_int = 94; +pub const KE_DROP: c_int = 95; +pub const KE_NOP: c_int = 97; +pub const KE_MOUSEMOVE: c_int = 100; +pub const KE_EVENT: c_int = 102; +pub const KE_LUA: c_int = 103; +pub const KE_COMMAND: c_int = 104; +pub const enum_key_extra = c_uint; +pub const REPTERM_FROM_PART: c_int = 1; +pub const REPTERM_DO_LT: c_int = 2; +pub const REPTERM_NO_SPECIAL: c_int = 4; +pub const REPTERM_NO_SIMPLIFY: c_int = 8; +const enum_unnamed_131 = c_uint; +pub const FSK_KEYCODE: c_int = 1; +pub const FSK_KEEP_X_KEY: c_int = 2; +pub const FSK_IN_STRING: c_int = 4; +pub const FSK_SIMPLIFY: c_int = 8; +const enum_unnamed_132 = c_uint; +pub extern fn name_to_mod_mask(c: c_int) c_int; +pub extern fn simplify_key(key: c_int, modifiers: [*c]c_int) c_int; +pub extern fn handle_x_keys(key: c_int) c_int; +pub extern fn get_special_key_name(c: c_int, modifiers: c_int) [*c]u8; +pub extern fn trans_special(srcp: [*c][*c]const u8, src_len: usize, dst: [*c]u8, flags: c_int, escape_ks: bool, did_simplify: [*c]bool) c_uint; +pub extern fn special_to_buf(key: c_int, modifiers: c_int, escape_ks: bool, dst: [*c]u8) c_uint; +pub extern fn find_special_key(srcp: [*c][*c]const u8, src_len: usize, modp: [*c]c_int, flags: c_int, did_simplify: [*c]bool) c_int; +pub extern fn find_special_key_in_table(c: c_int) c_int; +pub extern fn get_special_key_code(name: [*c]const u8) c_int; +pub extern fn get_mouse_button(code: c_int, is_click: [*c]bool, is_drag: [*c]bool) c_int; +pub extern fn replace_termcodes(from: [*c]const u8, from_len: usize, bufp: [*c][*c]u8, flags: c_int, did_simplify: [*c]bool, cpo_flags: c_int) [*c]u8; +pub extern fn add_char2buf(c: c_int, s: [*c]u8) [*c]u8; +pub extern fn vim_strsave_escape_ks(p: [*c]u8) [*c]u8; +pub extern fn vim_unescape_ks(p: [*c]u8) void; +pub const kDirectionNotSet: c_int = 0; +pub const FORWARD: c_int = 1; +pub const BACKWARD: c_int = -1; +pub const FORWARD_FILE: c_int = 3; +pub const BACKWARD_FILE: c_int = -3; +pub const Direction = c_int; +pub const EXPAND_UNSUCCESSFUL: c_int = -2; +pub const EXPAND_OK: c_int = -1; +pub const EXPAND_NOTHING: c_int = 0; +pub const EXPAND_COMMANDS: c_int = 1; +pub const EXPAND_FILES: c_int = 2; +pub const EXPAND_DIRECTORIES: c_int = 3; +pub const EXPAND_SETTINGS: c_int = 4; +pub const EXPAND_BOOL_SETTINGS: c_int = 5; +pub const EXPAND_TAGS: c_int = 6; +pub const EXPAND_OLD_SETTING: c_int = 7; +pub const EXPAND_HELP: c_int = 8; +pub const EXPAND_BUFFERS: c_int = 9; +pub const EXPAND_EVENTS: c_int = 10; +pub const EXPAND_MENUS: c_int = 11; +pub const EXPAND_SYNTAX: c_int = 12; +pub const EXPAND_HIGHLIGHT: c_int = 13; +pub const EXPAND_AUGROUP: c_int = 14; +pub const EXPAND_USER_VARS: c_int = 15; +pub const EXPAND_MAPPINGS: c_int = 16; +pub const EXPAND_TAGS_LISTFILES: c_int = 17; +pub const EXPAND_FUNCTIONS: c_int = 18; +pub const EXPAND_USER_FUNC: c_int = 19; +pub const EXPAND_EXPRESSION: c_int = 20; +pub const EXPAND_MENUNAMES: c_int = 21; +pub const EXPAND_USER_COMMANDS: c_int = 22; +pub const EXPAND_USER_CMD_FLAGS: c_int = 23; +pub const EXPAND_USER_NARGS: c_int = 24; +pub const EXPAND_USER_COMPLETE: c_int = 25; +pub const EXPAND_ENV_VARS: c_int = 26; +pub const EXPAND_LANGUAGE: c_int = 27; +pub const EXPAND_COLORS: c_int = 28; +pub const EXPAND_COMPILER: c_int = 29; +pub const EXPAND_USER_DEFINED: c_int = 30; +pub const EXPAND_USER_LIST: c_int = 31; +pub const EXPAND_USER_LUA: c_int = 32; +pub const EXPAND_SHELLCMD: c_int = 33; +pub const EXPAND_SIGN: c_int = 34; +pub const EXPAND_PROFILE: c_int = 35; +pub const EXPAND_FILETYPE: c_int = 36; +pub const EXPAND_FILES_IN_PATH: c_int = 37; +pub const EXPAND_OWNSYNTAX: c_int = 38; +pub const EXPAND_LOCALES: c_int = 39; +pub const EXPAND_HISTORY: c_int = 40; +pub const EXPAND_USER: c_int = 41; +pub const EXPAND_SYNTIME: c_int = 42; +pub const EXPAND_USER_ADDR_TYPE: c_int = 43; +pub const EXPAND_PACKADD: c_int = 44; +pub const EXPAND_MESSAGES: c_int = 45; +pub const EXPAND_MAPCLEAR: c_int = 46; +pub const EXPAND_ARGLIST: c_int = 47; +pub const EXPAND_DIFF_BUFFERS: c_int = 48; +pub const EXPAND_BREAKPOINT: c_int = 49; +pub const EXPAND_SCRIPTNAMES: c_int = 50; +pub const EXPAND_RUNTIME: c_int = 51; +pub const EXPAND_CHECKHEALTH: c_int = 52; +pub const EXPAND_LUA: c_int = 53; +const enum_unnamed_133 = c_int; +pub const FOLD_TEXT_LEN: c_int = 51; +const enum_unnamed_134 = c_uint; +pub const kEqualFiles: c_int = 1; +pub const kDifferentFiles: c_int = 2; +pub const kBothFilesMissing: c_int = 4; +pub const kOneFileMissing: c_int = 6; +pub const kEqualFileNames: c_int = 7; +pub const enum_file_comparison = c_uint; +pub const FileComparison = enum_file_comparison; +pub extern fn path_full_compare(s1: [*c]u8, s2: [*c]u8, checkname: bool, expandenv: bool) FileComparison; +pub extern fn path_tail(fname: [*c]const u8) [*c]u8; +pub extern fn path_tail_with_sep(fname: [*c]u8) [*c]u8; +pub extern fn invocation_path_tail(invocation: [*c]const u8, len: [*c]usize) [*c]const u8; +pub extern fn path_next_component(fname: [*c]const u8) [*c]const u8; +pub extern fn path_head_length() c_int; +pub extern fn is_path_head(path: [*c]const u8) bool; +pub extern fn get_past_head(path: [*c]const u8) [*c]u8; +pub extern fn vim_ispathsep(c: c_int) c_int; +pub extern fn vim_ispathsep_nocolon(c: c_int) c_int; +pub extern fn vim_ispathlistsep(c: c_int) c_int; +pub extern fn shorten_dir_len(str: [*c]u8, trim_len: c_int) void; +pub extern fn shorten_dir(str: [*c]u8) void; +pub extern fn dir_of_file_exists(fname: [*c]u8) bool; +pub extern fn path_fnamecmp(fname1: [*c]const u8, fname2: [*c]const u8) c_int; +pub extern fn path_fnamencmp(fname1: [*c]const u8, fname2: [*c]const u8, len: usize) c_int; +pub extern fn concat_fnames(fname1: [*c]const u8, fname2: [*c]const u8, sep: bool) [*c]u8; +pub extern fn concat_fnames_realloc(fname1: [*c]u8, fname2: [*c]const u8, sep: bool) [*c]u8; +pub extern fn add_pathsep(p: [*c]u8) bool; +pub extern fn FullName_save(fname: [*c]const u8, force: bool) [*c]u8; +pub extern fn save_abs_path(name: [*c]const u8) [*c]u8; +pub extern fn path_has_wildcard(p: [*c]const u8) bool; +pub extern fn path_has_exp_wildcard(p: [*c]const u8) bool; +pub extern fn gettail_dir(fname: [*c]const u8) [*c]const u8; +pub extern fn gen_expand_wildcards(num_pat: c_int, pat: [*c][*c]u8, num_file: [*c]c_int, file: [*c][*c][*c]u8, flags: c_int) c_int; +pub extern fn FreeWild(count: c_int, files: [*c][*c]u8) void; +pub extern fn addfile(gap: [*c]garray_T, f: [*c]u8, flags: c_int) void; +pub extern fn simplify_filename(filename: [*c]u8) void; +pub extern fn find_file_name_in_path(ptr: [*c]u8, len: usize, options: c_int, count: c_long, rel_fname: [*c]u8) [*c]u8; +pub extern fn path_has_drive_letter(p: [*c]const u8) bool; +pub extern fn path_is_url(p: [*c]const u8) c_int; +pub extern fn path_with_url(fname: [*c]const u8) c_int; +pub extern fn path_with_extension(path: [*c]const u8, extension: [*c]const u8) bool; +pub extern fn vim_isAbsName(name: [*c]u8) bool; +pub extern fn vim_FullName(fname: [*c]const u8, buf: [*c]u8, len: usize, force: bool) c_int; +pub extern fn fix_fname(fname: [*c]const u8) [*c]u8; +pub extern fn path_fix_case(name: [*c]u8) void; +pub extern fn after_pathsep(b: [*c]const u8, p: [*c]const u8) c_int; +pub extern fn same_directory(f1: [*c]u8, f2: [*c]u8) bool; +pub extern fn pathcmp(p: [*c]const u8, q: [*c]const u8, maxlen: c_int) c_int; +pub extern fn path_try_shorten_fname(full_path: [*c]u8) [*c]u8; +pub extern fn path_shorten_fname(full_path: [*c]u8, dir_name: [*c]u8) [*c]u8; +pub extern fn expand_wildcards_eval(pat: [*c][*c]u8, num_file: [*c]c_int, file: [*c][*c][*c]u8, flags: c_int) c_int; +pub extern fn expand_wildcards(num_pat: c_int, pat: [*c][*c]u8, num_files: [*c]c_int, files: [*c][*c][*c]u8, flags: c_int) c_int; +pub extern fn match_suffix(fname: [*c]u8) c_int; +pub extern fn path_full_dir_name(directory: [*c]u8, buffer: [*c]u8, len: usize) c_int; +pub extern fn append_path(path: [*c]u8, to_append: [*c]const u8, max_len: usize) c_int; +pub extern fn path_is_absolute(fname: [*c]const u8) c_int; +pub extern fn path_guess_exepath(argv0: [*c]const u8, buf: [*c]u8, bufsize: usize) void; +pub const struct_winsize = extern struct { + ws_row: c_ushort, + ws_col: c_ushort, + ws_xpixel: c_ushort, + ws_ypixel: c_ushort, +}; +pub const struct_pty_process = extern struct { + process: Process, + width: u16, + height: u16, + winsize: struct_winsize, + tty_fd: c_int, +}; +pub const PtyProcess = struct_pty_process; +const union_unnamed_135 = extern union { + proc: Process, + uv: LibuvProcess, + pty: PtyProcess, + socket: Stream, + stdio: StdioPair, + err: StderrState, + internal: InternalState, +}; +pub const struct_Channel = extern struct { + id: u64, + refcount: usize, + events: ?*MultiQueue, + streamtype: ChannelStreamType, + stream: union_unnamed_135, + is_rpc: bool, + rpc: RpcState, + term: ?*Terminal, + on_data: CallbackReader, + on_stderr: CallbackReader, + on_exit: Callback, + exit_status: c_int, + callback_busy: bool, + callback_scheduled: bool, +}; +pub const Channel = struct_Channel; +pub const mpack_uint32_t = c_uint; +pub const struct_mpack_value_s = extern struct { + lo: mpack_uint32_t, + hi: mpack_uint32_t, +}; +pub const mpack_value_t = struct_mpack_value_s; +const union_unnamed_136 = extern union { + value: mpack_value_t, + chunk_ptr: [*c]const u8, + ext_type: c_int, +}; +pub const struct_mpack_token_s = extern struct { + type: mpack_token_type_t, + length: mpack_uint32_t, + data: union_unnamed_136, +}; +pub const mpack_token_t = struct_mpack_token_s; +pub const struct_mpack_tokbuf_s = extern struct { + pending: [9]u8, + pending_tok: mpack_token_t, + ppos: usize, + plen: usize, + passthrough: mpack_uint32_t, +}; +pub const mpack_tokbuf_t = struct_mpack_tokbuf_s; +pub const struct_Unpacker = extern struct { + parser: mpack_parser_t, + reader: mpack_tokbuf_t, + read_ptr: [*c]const u8, + read_size: usize, + ext_buf: [9]u8, + state: c_int, + type: MessageType, + request_id: u32, + method_name_len: usize, + handler: MsgpackRpcRequestHandler, + @"error": Object, + result: Object, + unpack_error: Error, + arena: Arena, + nevents: c_int, + ncalls: c_int, + ui_handler: UIClientHandler, + grid_line_event: [*c]GridLineEvent, +}; +pub const Unpacker = struct_Unpacker; +pub const ChannelCallFrame = extern struct { + request_id: u32, + returned: bool, + errored: bool, + result: Object, + result_mem: ArenaMem, +}; +pub const RequestEvent = extern struct { + type: MessageType, + channel: [*c]Channel, + handler: MsgpackRpcRequestHandler, + args: Array, + request_id: u32, + used_mem: Arena, +}; +const struct_unnamed_137 = extern struct { + size: usize, + capacity: usize, + items: [*c][*c]ChannelCallFrame, +}; +pub const RpcState = extern struct { + subscribed_events: [1]Map_cstr_t_ptr_t, + closed: bool, + unpacker: [*c]Unpacker, + next_request_id: u32, + call_stack: struct_unnamed_137, + info: Dictionary, +}; +pub const struct_termio = extern struct { + c_iflag: c_ushort, + c_oflag: c_ushort, + c_cflag: c_ushort, + c_lflag: c_ushort, + c_line: u8, + c_cc: [8]u8, +}; +pub extern fn ioctl(__fd: c_int, __request: c_ulong, ...) c_int; +pub fn pty_process_init(arg_loop_1: [*c]Loop, arg_data: ?*anyopaque) callconv(.C) PtyProcess { + var loop_1 = arg_loop_1; + var data = arg_data; + var rv: PtyProcess = undefined; + rv.process = process_init(loop_1, @bitCast(c_uint, kProcessTypePty), data); + rv.width = 80; + rv.height = 24; + rv.tty_fd = -@as(c_int, 1); + return rv; +} +pub extern fn pty_process_spawn(ptyproc: [*c]PtyProcess) c_int; +pub extern fn pty_process_tty_name(ptyproc: [*c]PtyProcess) [*c]const u8; +pub extern fn pty_process_resize(ptyproc: [*c]PtyProcess, width: u16, height: u16) void; +pub extern fn pty_process_close(ptyproc: [*c]PtyProcess) void; +pub extern fn pty_process_close_master(ptyproc: [*c]PtyProcess) void; +pub extern fn pty_process_teardown(loop: [*c]Loop) void; +pub const kChannelStreamProc: c_int = 0; +pub const kChannelStreamSocket: c_int = 1; +pub const kChannelStreamStdio: c_int = 2; +pub const kChannelStreamStderr: c_int = 3; +pub const kChannelStreamInternal: c_int = 4; +pub const ChannelStreamType = c_uint; +pub const kChannelPartStdin: c_int = 0; +pub const kChannelPartStdout: c_int = 1; +pub const kChannelPartStderr: c_int = 2; +pub const kChannelPartRpc: c_int = 3; +pub const kChannelPartAll: c_int = 4; +pub const ChannelPart = c_uint; +pub const kChannelStdinPipe: c_int = 0; +pub const kChannelStdinNull: c_int = 1; +pub const ChannelStdinMode = c_uint; +pub const StdioPair = extern struct { + in: Stream, + out: Stream, +}; +pub const StderrState = extern struct { + closed: bool, +}; +pub const InternalState = extern struct { + cb: LuaRef, + closed: bool, +}; +pub const CallbackReader = extern struct { + cb: Callback, + self: [*c]dict_T, + buffer: garray_T, + eof: bool, + buffered: bool, + fwd_err: bool, + type: [*c]const u8, +}; +pub fn callback_reader_set(arg_reader: CallbackReader) callconv(.C) bool { + var reader = arg_reader; + return (reader.cb.type != @bitCast(c_uint, kCallbackNone)) or (reader.self != null); +} +pub extern var channels: Map_uint64_t_ptr_t; +pub extern var on_print: Callback; +pub extern fn channel_teardown() void; +pub extern fn channel_close(id: u64, part: ChannelPart, @"error": [*c][*c]const u8) bool; +pub extern fn channel_init() void; +pub extern fn channel_alloc(@"type": ChannelStreamType) [*c]Channel; +pub extern fn channel_create_event(chan: [*c]Channel, ext_source: [*c]const u8) void; +pub extern fn channel_incref(chan: [*c]Channel) void; +pub extern fn channel_decref(chan: [*c]Channel) void; +pub extern fn callback_reader_free(reader: [*c]CallbackReader) void; +pub extern fn callback_reader_start(reader: [*c]CallbackReader, @"type": [*c]const u8) void; +pub extern fn channel_job_start(argv: [*c][*c]u8, on_stdout: CallbackReader, on_stderr: CallbackReader, on_exit: Callback, pty: bool, rpc: bool, overlapped: bool, detach: bool, stdin_mode: ChannelStdinMode, cwd: [*c]const u8, pty_width: u16, pty_height: u16, env: [*c]dict_T, status_out: [*c]varnumber_T) [*c]Channel; +pub extern fn channel_connect(tcp: bool, address: [*c]const u8, rpc: bool, on_output: CallbackReader, timeout: c_int, @"error": [*c][*c]const u8) u64; +pub extern fn channel_from_connection(watcher: [*c]SocketWatcher) void; +pub extern fn channel_from_stdio(rpc: bool, on_output: CallbackReader, @"error": [*c][*c]const u8) u64; +pub extern fn channel_send(id: u64, data: [*c]u8, len: usize, data_owned: bool, @"error": [*c][*c]const u8) usize; +pub extern fn on_channel_data(stream: [*c]Stream, buf: [*c]RBuffer, count: usize, data: ?*anyopaque, eof: bool) void; +pub extern fn on_job_stderr(stream: [*c]Stream, buf: [*c]RBuffer, count: usize, data: ?*anyopaque, eof: bool) void; +pub extern fn channel_reader_callbacks(chan: [*c]Channel, reader: [*c]CallbackReader) void; +pub extern fn channel_terminal_open(buf: [*c]buf_T, chan: [*c]Channel) void; +pub extern fn channel_info_changed(chan: [*c]Channel, new_chan: bool) void; +pub extern fn channel_job_running(id: u64) bool; +pub extern fn channel_info(id: u64) Dictionary; +pub extern fn channel_all_info() Array; +pub fn find_channel(arg_id: u64) callconv(.C) [*c]Channel { + var id = arg_id; + return @ptrCast([*c]Channel, @alignCast(@import("std").meta.alignment([*c]Channel), map_uint64_t_ptr_t_get(&channels, id))); +} +pub fn channel_instream(arg_chan: [*c]Channel) callconv(.C) [*c]Stream { + var chan = arg_chan; + while (true) { + switch (chan.*.streamtype) { + @bitCast(c_uint, @as(c_int, 0)) => return &chan.*.stream.proc.in, + @bitCast(c_uint, @as(c_int, 1)) => return &chan.*.stream.socket, + @bitCast(c_uint, @as(c_int, 2)) => return &chan.*.stream.stdio.out, + @bitCast(c_uint, @as(c_int, 4)), @bitCast(c_uint, @as(c_int, 3)) => { + abort(); + }, + else => {}, + } + break; + } + abort(); + return null; +} +pub fn channel_outstream(arg_chan: [*c]Channel) callconv(.C) [*c]Stream { + var chan = arg_chan; + while (true) { + switch (chan.*.streamtype) { + @bitCast(c_uint, @as(c_int, 0)) => return &chan.*.stream.proc.out, + @bitCast(c_uint, @as(c_int, 1)) => return &chan.*.stream.socket, + @bitCast(c_uint, @as(c_int, 2)) => return &chan.*.stream.stdio.in, + @bitCast(c_uint, @as(c_int, 4)), @bitCast(c_uint, @as(c_int, 3)) => { + abort(); + }, + else => {}, + } + break; + } + abort(); + return null; +} +pub const STR2NR_DEC: c_int = 0; +pub const STR2NR_BIN: c_int = 1; +pub const STR2NR_OCT: c_int = 2; +pub const STR2NR_HEX: c_int = 4; +pub const STR2NR_OOCT: c_int = 8; +pub const STR2NR_FORCE: c_int = 128; +pub const STR2NR_ALL: c_int = 15; +pub const STR2NR_NO_OCT: c_int = 13; +pub const STR2NR_QUOTE: c_int = 16; +pub const ChStr2NrFlags = c_uint; +pub extern fn init_chartab() c_int; +pub extern fn buf_init_chartab(buf: [*c]buf_T, global: c_int) c_int; +pub extern fn trans_characters(buf: [*c]u8, bufsize: c_int) void; +pub extern fn transstr_len(s: [*c]const u8, untab: bool) usize; +pub extern fn transstr_buf(s: [*c]const u8, slen: isize, buf: [*c]u8, buflen: usize, untab: bool) usize; +pub extern fn transstr(s: [*c]const u8, untab: bool) [*c]u8; +pub extern fn kv_transstr(str: [*c]StringBuilder, s: [*c]const u8, untab: bool) usize; +pub extern fn str_foldcase(str: [*c]u8, orglen: c_int, buf: [*c]u8, buflen: c_int) [*c]u8; +pub extern fn transchar(c: c_int) [*c]u8; +pub extern fn transchar_buf(buf: [*c]const buf_T, c: c_int) [*c]u8; +pub extern fn transchar_byte(c: c_int) [*c]u8; +pub extern fn transchar_byte_buf(buf: [*c]const buf_T, c: c_int) [*c]u8; +pub extern fn transchar_nonprint(buf: [*c]const buf_T, charbuf: [*c]u8, c: c_int) void; +pub extern fn transchar_hex(buf: [*c]u8, c: c_int) usize; +pub extern fn rl_mirror_ascii(str: [*c]u8) void; +pub extern fn byte2cells(b: c_int) c_int; +pub extern fn char2cells(c: c_int) c_int; +pub extern fn ptr2cells(p_in: [*c]const u8) c_int; +pub extern fn vim_strsize(s: [*c]const u8) c_int; +pub extern fn vim_strnsize(s: [*c]const u8, len: c_int) c_int; +pub extern fn vim_isIDc(c: c_int) bool; +pub extern fn vim_iswordc(c: c_int) bool; +pub extern fn vim_iswordc_tab(c: c_int, chartab: [*c]const u64) bool; +pub extern fn vim_iswordc_buf(c: c_int, buf: [*c]buf_T) bool; +pub extern fn vim_iswordp(p: [*c]const u8) bool; +pub extern fn vim_iswordp_buf(p: [*c]const u8, buf: [*c]buf_T) bool; +pub extern fn vim_isfilec(c: c_int) bool; +pub extern fn vim_isfilec_or_wc(c: c_int) bool; +pub extern fn vim_isprintc(c: c_int) bool; +pub extern fn vim_isprintc_strict(c: c_int) bool; +pub extern fn in_win_border(wp: [*c]win_T, vcol: colnr_T) bool; +pub extern fn getvcol(wp: [*c]win_T, pos: [*c]pos_T, start: [*c]colnr_T, cursor: [*c]colnr_T, end: [*c]colnr_T) void; +pub extern fn getvcol_nolist(posp: [*c]pos_T) colnr_T; +pub extern fn getvvcol(wp: [*c]win_T, pos: [*c]pos_T, start: [*c]colnr_T, cursor: [*c]colnr_T, end: [*c]colnr_T) void; +pub extern fn getvcols(wp: [*c]win_T, pos1: [*c]pos_T, pos2: [*c]pos_T, left: [*c]colnr_T, right: [*c]colnr_T) void; +pub extern fn skipwhite(p: [*c]const u8) [*c]u8; +pub extern fn skipwhite_len(p: [*c]const u8, len: usize) [*c]u8; +pub extern fn getwhitecols_curline() isize; +pub extern fn getwhitecols(p: [*c]const u8) isize; +pub extern fn skipdigits(q: [*c]const u8) [*c]u8; +pub extern fn skipbin(q: [*c]const u8) [*c]const u8; +pub extern fn skiphex(q: [*c]u8) [*c]u8; +pub extern fn skiptodigit(q: [*c]u8) [*c]u8; +pub extern fn skiptobin(q: [*c]const u8) [*c]const u8; +pub extern fn skiptohex(q: [*c]u8) [*c]u8; +pub extern fn skiptowhite(p: [*c]const u8) [*c]u8; +pub extern fn skiptowhite_esc(p: [*c]u8) [*c]u8; +pub extern fn skip_to_newline(p: [*c]const u8) [*c]u8; +pub extern fn try_getdigits(pp: [*c][*c]u8, nr: [*c]intmax_t) bool; +pub extern fn getdigits(pp: [*c][*c]u8, strict: bool, def: intmax_t) intmax_t; +pub extern fn getdigits_int(pp: [*c][*c]u8, strict: bool, def: c_int) c_int; +pub extern fn getdigits_long(pp: [*c][*c]u8, strict: bool, def: c_long) c_long; +pub extern fn getdigits_int32(pp: [*c][*c]u8, strict: bool, def: c_long) i32; +pub extern fn vim_isblankline(lbuf: [*c]u8) bool; +pub extern fn vim_str2nr(start: [*c]const u8, prep: [*c]c_int, len: [*c]c_int, what: c_int, nptr: [*c]varnumber_T, unptr: [*c]uvarnumber_T, maxlen: c_int, strict: bool, overflow: [*c]bool) void; +pub extern fn hex2nr(c: c_int) c_int; +pub extern fn hexhex2nr(p: [*c]const u8) c_int; +pub extern fn rem_backslash(str: [*c]const u8) bool; +pub extern fn backslash_halve(p: [*c]u8) void; +pub extern fn backslash_halve_save(p: [*c]const u8) [*c]u8; +pub inline fn vim_isbreak(arg_c: c_int) bool { + var c = arg_c; + return breakat_flags[@bitCast(u8, @truncate(i8, c))] != 0; +} +pub const CmdlineInfo = struct_cmdline_info; +pub const struct_cmdline_info = extern struct { + cmdbuff: [*c]u8, + cmdbufflen: c_int, + cmdlen: c_int, + cmdpos: c_int, + cmdspos: c_int, + cmdfirstc: c_int, + cmdindent: c_int, + cmdprompt: [*c]u8, + cmdattr: c_int, + overstrike: c_int, + xpc: [*c]expand_T, + xp_context: c_int, + xp_arg: [*c]u8, + input_fn: c_int, + prompt_id: c_uint, + highlight_callback: Callback, + last_colors: ColoredCmdline, + level: c_int, + prev_ccline: [*c]CmdlineInfo, + special_char: u8, + special_shift: bool, + redraw_state: CmdRedraw, +}; +pub const CmdlineColorChunk = extern struct { + start: c_int, + end: c_int, + attr: c_int, +}; +pub const CmdlineColors = extern struct { + size: usize, + capacity: usize, + items: [*c]CmdlineColorChunk, +}; +pub const ColoredCmdline = extern struct { + prompt_id: c_uint, + cmdbuff: [*c]u8, + colors: CmdlineColors, +}; +pub const kCmdRedrawNone: c_int = 0; +pub const kCmdRedrawPos: c_int = 1; +pub const kCmdRedrawAll: c_int = 2; +pub const CmdRedraw = c_uint; +pub const VSE_NONE: c_int = 0; +pub const VSE_SHELL: c_int = 1; +pub const VSE_BUFFER: c_int = 2; +const enum_unnamed_138 = c_uint; +pub extern fn cmdpreview_get_bufnr() handle_T; +pub extern fn cmdpreview_get_ns() c_long; +pub extern fn getcmdline(firstc: c_int, count: c_long, indent: c_int, do_concat: bool) [*c]u8; +pub extern fn getcmdline_prompt(firstc: c_int, prompt: [*c]const u8, attr: c_int, xp_context: c_int, xp_arg: [*c]const u8, highlight_callback: Callback) [*c]u8; +pub extern fn check_opt_wim() c_int; +pub extern fn text_locked() bool; +pub extern fn text_locked_msg() void; +pub extern fn get_text_locked_msg() [*c]const u8; +pub extern fn text_or_buf_locked() bool; +pub extern fn curbuf_locked() bool; +pub extern fn allbuf_locked() bool; +pub extern fn cmd_screencol(bytepos: c_int) c_int; +pub extern fn getexline(c: c_int, cookie: ?*anyopaque, indent: c_int, do_concat: bool) [*c]u8; +pub extern fn cmdline_overstrike() bool; +pub extern fn cmdline_at_end() bool; +pub extern fn realloc_cmdbuff(len: c_int) void; +pub extern fn ui_ext_cmdline_block_append(indent: usize, line: [*c]const u8) void; +pub extern fn ui_ext_cmdline_block_leave() void; +pub extern fn cmdline_screen_cleared() void; +pub extern fn cmdline_ui_flush() void; +pub extern fn putcmdline(c: u8, shift: c_int) void; +pub extern fn unputcmdline() void; +pub extern fn put_on_cmdline(str: [*c]u8, len: c_int, redraw: c_int) void; +pub extern fn cmdline_paste_str(s: [*c]u8, literally: c_int) void; +pub extern fn redrawcmdline() void; +pub extern fn redrawcmd() void; +pub extern fn compute_cmdrow() void; +pub extern fn cursorcmd() void; +pub extern fn gotocmdline(clr: bool) void; +pub extern fn vim_strsave_fnameescape(fname: [*c]const u8, what: c_int) [*c]u8; +pub extern fn escape_fname(pp: [*c][*c]u8) void; +pub extern fn tilde_replace(orig_pat: [*c]u8, num_files: c_int, files: [*c][*c]u8) void; +pub extern fn get_cmdline_info() [*c]CmdlineInfo; +pub extern fn get_cmdline_last_prompt_id() c_uint; +pub extern fn f_getcmdcompltype(argvars: [*c]typval_T, rettv: [*c]typval_T, fptr: EvalFuncData) void; +pub extern fn f_getcmdline(argvars: [*c]typval_T, rettv: [*c]typval_T, fptr: EvalFuncData) void; +pub extern fn f_getcmdpos(argvars: [*c]typval_T, rettv: [*c]typval_T, fptr: EvalFuncData) void; +pub extern fn f_getcmdscreenpos(argvars: [*c]typval_T, rettv: [*c]typval_T, fptr: EvalFuncData) void; +pub extern fn f_getcmdtype(argvars: [*c]typval_T, rettv: [*c]typval_T, fptr: EvalFuncData) void; +pub extern fn f_setcmdline(argvars: [*c]typval_T, rettv: [*c]typval_T, fptr: EvalFuncData) void; +pub extern fn f_setcmdpos(argvars: [*c]typval_T, rettv: [*c]typval_T, fptr: EvalFuncData) void; +pub extern fn get_cmdline_firstc() c_int; +pub extern fn get_list_range(str: [*c][*c]u8, num1: [*c]c_int, num2: [*c]c_int) c_int; +pub extern fn cmdline_init() void; +pub extern fn check_cedit() [*c]const u8; +pub extern fn is_in_cmdwin() bool; +pub extern fn script_get(eap: [*c]exarg_T, lenp: [*c]usize) [*c]u8; +pub const WILD_FREE: c_int = 1; +pub const WILD_EXPAND_FREE: c_int = 2; +pub const WILD_EXPAND_KEEP: c_int = 3; +pub const WILD_NEXT: c_int = 4; +pub const WILD_PREV: c_int = 5; +pub const WILD_ALL: c_int = 6; +pub const WILD_LONGEST: c_int = 7; +pub const WILD_ALL_KEEP: c_int = 8; +pub const WILD_CANCEL: c_int = 9; +pub const WILD_APPLY: c_int = 10; +pub const WILD_PAGEUP: c_int = 11; +pub const WILD_PAGEDOWN: c_int = 12; +pub const WILD_PUM_WANT: c_int = 13; +const enum_unnamed_139 = c_uint; +pub const WILD_LIST_NOTFOUND: c_int = 1; +pub const WILD_HOME_REPLACE: c_int = 2; +pub const WILD_USE_NL: c_int = 4; +pub const WILD_NO_BEEP: c_int = 8; +pub const WILD_ADD_SLASH: c_int = 16; +pub const WILD_KEEP_ALL: c_int = 32; +pub const WILD_SILENT: c_int = 64; +pub const WILD_ESCAPE: c_int = 128; +pub const WILD_ICASE: c_int = 256; +pub const WILD_ALLLINKS: c_int = 512; +pub const WILD_IGNORE_COMPLETESLASH: c_int = 1024; +pub const WILD_NOERROR: c_int = 2048; +pub const WILD_BUFLASTUSED: c_int = 4096; +pub const BUF_DIFF_FILTER: c_int = 8192; +const enum_unnamed_140 = c_uint; +pub extern fn cmdline_fuzzy_complete(fuzzystr: [*c]const u8) bool; +pub extern fn nextwild(xp: [*c]expand_T, @"type": c_int, options: c_int, escape: bool) c_int; +pub extern fn cmdline_pum_display(changed_array: bool) void; +pub extern fn cmdline_pum_active() bool; +pub extern fn cmdline_pum_remove() void; +pub extern fn cmdline_pum_cleanup(cclp: [*c]CmdlineInfo) void; +pub extern fn ExpandOne(xp: [*c]expand_T, str: [*c]u8, orig: [*c]u8, options: c_int, mode: c_int) [*c]u8; +pub extern fn ExpandInit(xp: [*c]expand_T) void; +pub extern fn ExpandCleanup(xp: [*c]expand_T) void; +pub extern fn showmatches(xp: [*c]expand_T, wildmenu: c_int) c_int; +pub extern fn addstar(fname: [*c]u8, len: usize, context: c_int) [*c]u8; +pub extern fn set_expand_context(xp: [*c]expand_T) void; +pub extern fn set_cmd_context(xp: [*c]expand_T, str: [*c]u8, len: c_int, col: c_int, use_ccline: c_int) void; +pub extern fn expand_cmdline(xp: [*c]expand_T, str: [*c]const u8, col: c_int, matchcount: [*c]c_int, matches: [*c][*c][*c]u8) c_int; +pub extern fn globpath(path: [*c]u8, file: [*c]u8, ga: [*c]garray_T, expand_options: c_int, dirs: bool) void; +pub extern fn wildmenu_translate_key(cclp: [*c]CmdlineInfo, key: c_int, xp: [*c]expand_T, did_wild_list: c_int) c_int; +pub extern fn wildmenu_process_key(cclp: [*c]CmdlineInfo, key: c_int, xp: [*c]expand_T) c_int; +pub extern fn wildmenu_cleanup(cclp: [*c]CmdlineInfo) void; +pub extern fn f_getcompletion(argvars: [*c]typval_T, rettv: [*c]typval_T, fptr: EvalFuncData) void; +pub const HIST_DEFAULT: c_int = -2; +pub const HIST_INVALID: c_int = -1; +pub const HIST_CMD: c_int = 0; +pub const HIST_SEARCH: c_int = 1; +pub const HIST_EXPR: c_int = 2; +pub const HIST_INPUT: c_int = 3; +pub const HIST_DEBUG: c_int = 4; +pub const HistoryType = c_int; +pub const struct_hist_entry = extern struct { + hisnum: c_int, + hisstr: [*c]u8, + timestamp: Timestamp, + additional_elements: [*c]list_T, +}; +pub const histentry_T = struct_hist_entry; +pub extern fn get_hislen() c_int; +pub extern fn get_histentry(hist_type: c_int) [*c]histentry_T; +pub extern fn set_histentry(hist_type: c_int, entry: [*c]histentry_T) void; +pub extern fn get_hisidx(hist_type: c_int) [*c]c_int; +pub extern fn get_hisnum(hist_type: c_int) [*c]c_int; +pub extern fn hist_char2type(c: c_int) HistoryType; +pub extern fn get_history_arg(xp: [*c]expand_T, idx: c_int) [*c]u8; +pub extern fn init_history() void; +pub extern fn add_to_history(histype: c_int, new_entry: [*c]u8, in_map: c_int, sep: c_int) void; +pub extern fn clr_history(histype: c_int) c_int; +pub extern fn f_histadd(argvars: [*c]typval_T, rettv: [*c]typval_T, fptr: EvalFuncData) void; +pub extern fn f_histdel(argvars: [*c]typval_T, rettv: [*c]typval_T, fptr: EvalFuncData) void; +pub extern fn f_histget(argvars: [*c]typval_T, rettv: [*c]typval_T, fptr: EvalFuncData) void; +pub extern fn f_histnr(argvars: [*c]typval_T, rettv: [*c]typval_T, fptr: EvalFuncData) void; +pub extern fn ex_history(eap: [*c]exarg_T) void; +pub extern fn hist_iter(iter: ?*const anyopaque, history_type: u8, zero: bool, hist: [*c]histentry_T) ?*const anyopaque; +pub extern fn hist_get_array(history_type: u8, new_hisidx: [*c][*c]c_int, new_hisnum: [*c][*c]c_int) [*c]histentry_T; +pub const Context = extern struct { + regs: msgpack_sbuffer, + jumps: msgpack_sbuffer, + bufs: msgpack_sbuffer, + gvars: msgpack_sbuffer, + funcs: Array, +}; +pub const ContextVec = extern struct { + size: usize, + capacity: usize, + items: [*c]Context, +}; +pub const kCtxRegs: c_int = 1; +pub const kCtxJumps: c_int = 2; +pub const kCtxBufs: c_int = 4; +pub const kCtxGVars: c_int = 8; +pub const kCtxSFuncs: c_int = 16; +pub const kCtxFuncs: c_int = 32; +pub const ContextTypeFlags = c_uint; +pub extern var kCtxAll: c_int; +pub extern fn ctx_free_all() void; +pub extern fn ctx_size() usize; +pub extern fn ctx_get(index: usize) [*c]Context; +pub extern fn ctx_free(ctx: [*c]Context) void; +pub extern fn ctx_save(ctx: [*c]Context, flags: c_int) void; +pub extern fn ctx_restore(ctx: [*c]Context, flags: c_int) bool; +pub extern fn ctx_to_dict(ctx: [*c]Context) Dictionary; +pub extern fn ctx_from_dict(dict: Dictionary, ctx: [*c]Context) c_int; +pub extern fn getviscol() c_int; +pub extern fn getviscol2(col: colnr_T, coladd: colnr_T) c_int; +pub extern fn coladvance_force(wcol: colnr_T) c_int; +pub extern fn coladvance(wcol: colnr_T) c_int; +pub extern fn getvpos(pos: [*c]pos_T, wcol: colnr_T) c_int; +pub extern fn inc_cursor() c_int; +pub extern fn dec_cursor() c_int; +pub extern fn get_cursor_rel_lnum(wp: [*c]win_T, lnum: linenr_T) linenr_T; +pub extern fn check_pos(buf: [*c]buf_T, pos: [*c]pos_T) void; +pub extern fn check_cursor_lnum() void; +pub extern fn check_cursor_col() void; +pub extern fn check_cursor_col_win(win: [*c]win_T) void; +pub extern fn check_cursor() void; +pub extern fn check_visual_pos() void; +pub extern fn adjust_cursor_col() void; +pub extern fn leftcol_changed() bool; +pub extern fn gchar_cursor() c_int; +pub extern fn pchar_cursor(c: u8) void; +pub extern fn get_cursor_line_ptr() [*c]u8; +pub extern fn get_cursor_pos_ptr() [*c]u8; +pub const SHAPE_IDX_N: c_int = 0; +pub const SHAPE_IDX_V: c_int = 1; +pub const SHAPE_IDX_I: c_int = 2; +pub const SHAPE_IDX_R: c_int = 3; +pub const SHAPE_IDX_C: c_int = 4; +pub const SHAPE_IDX_CI: c_int = 5; +pub const SHAPE_IDX_CR: c_int = 6; +pub const SHAPE_IDX_O: c_int = 7; +pub const SHAPE_IDX_VE: c_int = 8; +pub const SHAPE_IDX_CLINE: c_int = 9; +pub const SHAPE_IDX_STATUS: c_int = 10; +pub const SHAPE_IDX_SDRAG: c_int = 11; +pub const SHAPE_IDX_VSEP: c_int = 12; +pub const SHAPE_IDX_VDRAG: c_int = 13; +pub const SHAPE_IDX_MORE: c_int = 14; +pub const SHAPE_IDX_MOREL: c_int = 15; +pub const SHAPE_IDX_SM: c_int = 16; +pub const SHAPE_IDX_COUNT: c_int = 17; +pub const ModeShape = c_uint; +pub const SHAPE_BLOCK: c_int = 0; +pub const SHAPE_HOR: c_int = 1; +pub const SHAPE_VER: c_int = 2; +pub const CursorShape = c_uint; +pub const struct_cursor_entry = extern struct { + full_name: [*c]u8, + shape: CursorShape, + mshape: c_int, + percentage: c_int, + blinkwait: c_long, + blinkon: c_long, + blinkoff: c_long, + id: c_int, + id_lm: c_int, + name: [*c]u8, + used_for: u8, +}; +pub const cursorentry_T = struct_cursor_entry; +pub extern var shape_table: [17]cursorentry_T; +pub extern fn mode_style_array(arena: [*c]Arena) Array; +pub extern fn parse_shape_opt(what: c_int) [*c]u8; +pub extern fn cursor_is_block_during_visual(exclusive: bool) bool; +pub extern fn cursor_mode_str2int(mode: [*c]const u8) c_int; +pub extern fn cursor_mode_uses_syn_id(syn_id: c_int) bool; +pub extern fn cursor_get_mode_idx() c_int; +pub extern fn do_debug(cmd: [*c]u8) void; +pub extern fn ex_debug(eap: [*c]exarg_T) void; +pub extern fn dbg_check_breakpoint(eap: [*c]exarg_T) void; +pub extern fn dbg_check_skipped(eap: [*c]exarg_T) bool; +pub extern fn ex_breakadd(eap: [*c]exarg_T) void; +pub extern fn ex_debuggreedy(eap: [*c]exarg_T) void; +pub extern fn ex_breakdel(eap: [*c]exarg_T) void; +pub extern fn ex_breaklist(eap: [*c]exarg_T) void; +pub extern fn dbg_find_breakpoint(file: bool, fname: [*c]u8, after: linenr_T) linenr_T; +pub extern fn has_profiling(file: bool, fname: [*c]u8, fp: [*c]bool) bool; +pub extern fn dbg_breakpoint(name: [*c]u8, lnum: linenr_T) void; +pub const DecorProvider = extern struct { + ns_id: NS, + active: bool, + redraw_start: LuaRef, + redraw_buf: LuaRef, + redraw_win: LuaRef, + redraw_line: LuaRef, + redraw_end: LuaRef, + hl_def: LuaRef, + spell_nav: LuaRef, + hl_valid: c_int, + hl_cached: bool, +}; +pub const DecorProviders = extern struct { + size: usize, + capacity: usize, + items: [*c][*c]DecorProvider, + init_array: [4][*c]DecorProvider, +}; +pub extern var provider_active: bool; +pub extern fn decor_providers_invoke_spell(wp: [*c]win_T, start_row: c_int, start_col: c_int, end_row: c_int, end_col: c_int, err: [*c][*c]u8) void; +pub extern fn decor_providers_start(providers: [*c]DecorProviders, err: [*c][*c]u8) void; +pub extern fn decor_providers_invoke_win(wp: [*c]win_T, providers: [*c]DecorProviders, line_providers: [*c]DecorProviders, err: [*c][*c]u8) void; +pub extern fn decor_providers_invoke_line(wp: [*c]win_T, providers: [*c]DecorProviders, row: c_int, has_decor: [*c]bool, err: [*c][*c]u8) void; +pub extern fn decor_providers_invoke_buf(buf: [*c]buf_T, providers: [*c]DecorProviders, err: [*c][*c]u8) void; +pub extern fn decor_providers_invoke_end(providers: [*c]DecorProviders, err: [*c][*c]u8) void; +pub extern fn decor_provider_invalidate_hl() void; +pub extern fn get_decor_provider(ns_id: NS, force: bool) [*c]DecorProvider; +pub extern fn decor_provider_clear(p: [*c]DecorProvider) void; +pub extern fn decor_free_all_mem() void; +pub extern var diff_context: c_int; +pub extern var diff_foldcolumn: c_int; +pub extern var diff_need_scrollbind: bool; +pub extern var need_diff_redraw: bool; +pub extern fn diff_buf_delete(buf: [*c]buf_T) void; +pub extern fn diff_buf_adjust(win: [*c]win_T) void; +pub extern fn diff_buf_add(buf: [*c]buf_T) void; +pub extern fn diff_invalidate(buf: [*c]buf_T) void; +pub extern fn diff_mark_adjust(line1: linenr_T, line2: linenr_T, amount: linenr_T, amount_after: linenr_T) void; +pub extern fn diff_redraw(dofold: bool) void; +pub extern fn diff_internal() c_int; +pub extern fn ex_diffupdate(eap: [*c]exarg_T) void; +pub extern fn ex_diffpatch(eap: [*c]exarg_T) void; +pub extern fn ex_diffsplit(eap: [*c]exarg_T) void; +pub extern fn ex_diffthis(eap: [*c]exarg_T) void; +pub extern fn diff_win_options(wp: [*c]win_T, addbuf: c_int) void; +pub extern fn ex_diffoff(eap: [*c]exarg_T) void; +pub extern fn diff_clear(tp: [*c]tabpage_T) void; +pub extern fn diff_linematch(dp: [*c]diff_T) bool; +pub extern fn diff_check_with_linestatus(wp: [*c]win_T, lnum: linenr_T, linestatus: [*c]c_int) c_int; +pub extern fn diff_check(wp: [*c]win_T, lnum: linenr_T) c_int; +pub extern fn diff_set_topline(fromwin: [*c]win_T, towin: [*c]win_T) void; +pub extern fn diffopt_changed() c_int; +pub extern fn diffopt_horizontal() bool; +pub extern fn diffopt_hiddenoff() bool; +pub extern fn diffopt_closeoff() bool; +pub extern fn diffopt_filler() bool; +pub extern fn diff_find_change(wp: [*c]win_T, lnum: linenr_T, startp: [*c]c_int, endp: [*c]c_int) bool; +pub extern fn diff_infold(wp: [*c]win_T, lnum: linenr_T) bool; +pub extern fn nv_diffgetput(put: bool, count: usize) void; +pub extern fn ex_diffgetput(eap: [*c]exarg_T) void; +pub extern fn diff_mode_buf(buf: [*c]buf_T) bool; +pub extern fn diff_move_to(dir: c_int, count: c_long) c_int; +pub extern fn diff_get_corresponding_line(buf1: [*c]buf_T, lnum1: linenr_T) linenr_T; +pub extern fn diff_lnum_win(lnum: linenr_T, wp: [*c]win_T) linenr_T; +pub extern fn do_digraph(c: c_int) c_int; +pub extern fn get_digraph_for_char(val_arg: c_int) [*c]u8; +pub extern fn get_digraph(cmdline: bool) c_int; +pub extern fn digraph_get(char1: c_int, char2: c_int, meta_char: bool) c_int; +pub extern fn check_digraph_chars_valid(char1: c_int, char2: c_int) bool; +pub extern fn putdigraph(str: [*c]u8) void; +pub extern fn listdigraphs(use_headers: bool) void; +pub extern fn digraph_getlist_common(list_all: bool, rettv: [*c]typval_T) void; +pub extern fn f_digraph_get(argvars: [*c]typval_T, rettv: [*c]typval_T, fptr: EvalFuncData) void; +pub extern fn f_digraph_getlist(argvars: [*c]typval_T, rettv: [*c]typval_T, fptr: EvalFuncData) void; +pub extern fn f_digraph_set(argvars: [*c]typval_T, rettv: [*c]typval_T, fptr: EvalFuncData) void; +pub extern fn f_digraph_setlist(argvars: [*c]typval_T, rettv: [*c]typval_T, fptr: EvalFuncData) void; +pub extern fn keymap_init() [*c]u8; +pub extern fn ex_loadkeymap(eap: [*c]exarg_T) void; +pub extern fn keymap_ga_clear(kmap_ga: [*c]garray_T) void; +pub extern fn get_keymap_str(wp: [*c]win_T, fmt: [*c]u8, buf: [*c]u8, len: c_int) bool; +pub extern var disable_fold_update: c_int; +pub extern fn copyFoldingState(wp_from: [*c]win_T, wp_to: [*c]win_T) void; +pub extern fn hasAnyFolding(win: [*c]win_T) c_int; +pub extern fn hasFolding(lnum: linenr_T, firstp: [*c]linenr_T, lastp: [*c]linenr_T) bool; +pub extern fn hasFoldingWin(win: [*c]win_T, lnum: linenr_T, firstp: [*c]linenr_T, lastp: [*c]linenr_T, cache: bool, infop: [*c]foldinfo_T) bool; +pub extern fn lineFolded(win: [*c]win_T, lnum: linenr_T) bool; +pub extern fn fold_info(win: [*c]win_T, lnum: linenr_T) foldinfo_T; +pub extern fn foldmethodIsManual(wp: [*c]win_T) c_int; +pub extern fn foldmethodIsIndent(wp: [*c]win_T) c_int; +pub extern fn foldmethodIsExpr(wp: [*c]win_T) c_int; +pub extern fn foldmethodIsMarker(wp: [*c]win_T) c_int; +pub extern fn foldmethodIsSyntax(wp: [*c]win_T) c_int; +pub extern fn foldmethodIsDiff(wp: [*c]win_T) c_int; +pub extern fn closeFold(pos: pos_T, count: c_long) void; +pub extern fn closeFoldRecurse(pos: pos_T) void; +pub extern fn opFoldRange(firstpos: pos_T, lastpos: pos_T, opening: c_int, recurse: c_int, had_visual: c_int) void; +pub extern fn openFold(pos: pos_T, count: c_long) void; +pub extern fn openFoldRecurse(pos: pos_T) void; +pub extern fn foldOpenCursor() void; +pub extern fn newFoldLevel() void; +pub extern fn foldCheckClose() void; +pub extern fn foldManualAllowed(create: bool) c_int; +pub extern fn foldCreate(wp: [*c]win_T, start: pos_T, end: pos_T) void; +pub extern fn deleteFold(wp: [*c]win_T, start: linenr_T, end: linenr_T, recursive: c_int, had_visual: bool) void; +pub extern fn clearFolding(win: [*c]win_T) void; +pub extern fn foldUpdate(wp: [*c]win_T, top: linenr_T, bot: linenr_T) void; +pub extern fn foldUpdateAfterInsert() void; +pub extern fn foldUpdateAll(win: [*c]win_T) void; +pub extern fn foldMoveTo(updown: bool, dir: c_int, count: c_long) c_int; +pub extern fn foldInitWin(new_win: [*c]win_T) void; +pub extern fn find_wl_entry(win: [*c]win_T, lnum: linenr_T) c_int; +pub extern fn foldAdjustVisual() void; +pub extern fn foldAdjustCursor() void; +pub extern fn cloneFoldGrowArray(from: [*c]garray_T, to: [*c]garray_T) void; +pub extern fn deleteFoldRecurse(bp: [*c]buf_T, gap: [*c]garray_T) void; +pub extern fn foldMarkAdjust(wp: [*c]win_T, line1: linenr_T, line2: linenr_T, amount: linenr_T, amount_after: linenr_T) void; +pub extern fn getDeepestNesting(wp: [*c]win_T) c_int; +pub extern fn get_foldtext(wp: [*c]win_T, lnum: linenr_T, lnume: linenr_T, foldinfo: foldinfo_T, buf: [*c]u8) [*c]u8; +pub extern fn foldMoveRange(wp: [*c]win_T, gap: [*c]garray_T, line1: linenr_T, line2: linenr_T, dest: linenr_T) void; +pub extern fn put_folds(fd: [*c]FILE, wp: [*c]win_T) c_int; +pub extern fn f_foldclosed(argvars: [*c]typval_T, rettv: [*c]typval_T, fptr: EvalFuncData) void; +pub extern fn f_foldclosedend(argvars: [*c]typval_T, rettv: [*c]typval_T, fptr: EvalFuncData) void; +pub extern fn f_foldlevel(argvars: [*c]typval_T, rettv: [*c]typval_T, fptr: EvalFuncData) void; +pub extern fn f_foldtext(argvars: [*c]typval_T, rettv: [*c]typval_T, fptr: EvalFuncData) void; +pub extern fn f_foldtextresult(argvars: [*c]typval_T, rettv: [*c]typval_T, fptr: EvalFuncData) void; +pub const WinExtmark = extern struct { + ns_id: NS, + mark_id: u64, + win_row: c_int, + win_col: c_int, +}; +const struct_unnamed_141 = extern struct { + size: usize, + capacity: usize, + items: [*c]WinExtmark, +}; +pub extern var win_extmark_arr: struct_unnamed_141; +pub extern var conceal_cursor_used: bool; +pub extern fn fill_foldcolumn(p: [*c]u8, wp: [*c]win_T, foldinfo: foldinfo_T, lnum: linenr_T) usize; +pub extern fn win_signcol_width(wp: [*c]win_T) c_int; +pub extern fn win_line(wp: [*c]win_T, lnum: linenr_T, startrow: c_int, endrow: c_int, nochange: bool, number_only: bool, foldinfo: foldinfo_T, providers: [*c]DecorProviders, provider_err: [*c][*c]u8) c_int; +pub const UPD_VALID: c_int = 10; +pub const UPD_INVERTED: c_int = 20; +pub const UPD_INVERTED_ALL: c_int = 25; +pub const UPD_REDRAW_TOP: c_int = 30; +pub const UPD_SOME_VALID: c_int = 35; +pub const UPD_NOT_VALID: c_int = 40; +pub const UPD_CLEAR: c_int = 50; +const enum_unnamed_142 = c_uint; +pub extern var updating_screen: bool; +pub extern var screen_search_hl: match_T; +pub extern fn conceal_check_cursor_line() void; +pub extern fn default_grid_alloc() bool; +pub extern fn screenclear() void; +pub extern fn screen_resize(width: c_int, height: c_int) void; +pub extern fn check_screensize() void; +pub extern fn redrawing() bool; +pub extern fn update_screen() c_int; +pub extern fn start_search_hl() void; +pub extern fn end_search_hl() void; +pub extern fn setcursor() void; +pub extern fn setcursor_mayforce(force: bool) void; +pub extern fn show_cursor_info_later(force: bool) void; +pub extern fn skip_showmode() bool; +pub extern fn showmode() c_int; +pub extern fn unshowmode(force: bool) void; +pub extern fn clearmode() void; +pub extern fn comp_col() void; +pub extern fn win_scroll_lines(wp: [*c]win_T, row: c_int, line_count: c_int) void; +pub extern fn win_draw_end(wp: [*c]win_T, c1: c_int, c2: c_int, draw_margin: bool, row: c_int, endrow: c_int, hl: hlf_T) void; +pub extern fn compute_foldcolumn(wp: [*c]win_T, col: c_int) c_int; +pub extern fn number_width(wp: [*c]win_T) c_int; +pub extern fn redraw_later(wp: [*c]win_T, @"type": c_int) void; +pub extern fn redraw_all_later(@"type": c_int) void; +pub extern fn screen_invalidate_highlights() void; +pub extern fn redraw_curbuf_later(@"type": c_int) void; +pub extern fn redraw_buf_later(buf: [*c]buf_T, @"type": c_int) void; +pub extern fn redraw_buf_line_later(buf: [*c]buf_T, line: linenr_T, force: bool) void; +pub extern fn redraw_buf_range_later(buf: [*c]buf_T, firstline: linenr_T, lastline: linenr_T) void; +pub extern fn redraw_buf_status_later(buf: [*c]buf_T) void; +pub extern fn status_redraw_all() void; +pub extern fn status_redraw_curbuf() void; +pub extern fn status_redraw_buf(buf: [*c]buf_T) void; +pub extern fn redraw_statuslines() void; +pub extern fn win_redraw_last_status(frp: [*c]const frame_T) void; +pub extern fn redrawWinline(wp: [*c]win_T, lnum: linenr_T) void; +pub extern fn conceal_cursor_line(wp: [*c]const win_T) bool; +pub extern fn win_cursorline_standout(wp: [*c]const win_T) bool; +pub extern fn redraw_for_cursorline(wp: [*c]win_T) void; +pub extern fn edit(cmdchar: c_int, startln: bool, count: c_long) bool; +pub extern fn ins_need_undo_get() bool; +pub extern fn ins_redraw(ready: bool) void; +pub extern fn edit_putchar(c: c_int, highlight: bool) void; +pub extern fn buf_prompt_text(buf: [*c]const buf_T) [*c]u8; +pub extern fn prompt_text() [*c]u8; +pub extern fn prompt_curpos_editable() bool; +pub extern fn edit_unputchar() void; +pub extern fn display_dollar(col: colnr_T) void; +pub extern fn undisplay_dollar() void; +pub extern fn change_indent(@"type": c_int, amount: c_int, round: c_int, replaced: c_int, call_changed_bytes: c_int) void; +pub extern fn truncate_spaces(line: [*c]u8) void; +pub extern fn backspace_until_column(col: c_int) void; +pub extern fn get_literal(no_simplify: bool) c_int; +pub extern fn insertchar(c: c_int, flags: c_int, second_indent: c_int) void; +pub extern fn start_arrow(end_insert_pos: [*c]pos_T) void; +pub extern fn stop_arrow() c_int; +pub extern fn set_last_insert(c: c_int) void; +pub extern fn beginline(flags: c_int) void; +pub extern fn oneright() c_int; +pub extern fn oneleft() c_int; +pub extern fn cursor_up_inner(wp: [*c]win_T, n: c_long) linenr_T; +pub extern fn cursor_up(n: c_long, upd_topline: c_int) c_int; +pub extern fn cursor_down_inner(wp: [*c]win_T, n: c_long) linenr_T; +pub extern fn cursor_down(n: c_long, upd_topline: c_int) c_int; +pub extern fn stuff_inserted(c: c_int, count: c_long, no_esc: c_int) c_int; +pub extern fn get_last_insert() [*c]u8; +pub extern fn get_last_insert_save() [*c]u8; +pub extern fn replace_push(c: c_int) void; +pub extern fn replace_push_mb(p: [*c]u8) c_int; +pub extern fn cindent_on() bool; +pub extern fn in_cinkeys(keytyped: c_int, when: c_int, line_is_empty: bool) bool; +pub extern fn ins_eol(c: c_int) bool; +pub extern fn ins_copychar(lnum: linenr_T) c_int; +pub extern fn get_nolist_virtcol() colnr_T; +pub extern fn get_can_cindent() bool; +pub extern fn set_can_cindent(val: bool) void; +pub extern fn ins_apply_autocmds(event: event_T) c_int; +pub const SignalWatcher = struct_signal_watcher; +pub const signal_cb = ?*const fn ([*c]SignalWatcher, c_int, ?*anyopaque) callconv(.C) void; +pub const signal_close_cb = ?*const fn ([*c]SignalWatcher, ?*anyopaque) callconv(.C) void; +pub const struct_signal_watcher = extern struct { + uv: uv_signal_t, + data: ?*anyopaque, + cb: signal_cb, + close_cb: signal_close_cb, + events: ?*MultiQueue, +}; +pub extern fn signal_watcher_init(loop: [*c]Loop, watcher: [*c]SignalWatcher, data: ?*anyopaque) void; +pub extern fn signal_watcher_start(watcher: [*c]SignalWatcher, cb: signal_cb, signum: c_int) void; +pub extern fn signal_watcher_stop(watcher: [*c]SignalWatcher) void; +pub extern fn signal_watcher_close(watcher: [*c]SignalWatcher, cb: signal_close_cb) void; +pub const TimeWatcher = struct_time_watcher; +pub const time_cb = ?*const fn ([*c]TimeWatcher, ?*anyopaque) callconv(.C) void; +pub const struct_time_watcher = extern struct { + uv: uv_timer_t, + data: ?*anyopaque, + cb: time_cb, + close_cb: time_cb, + events: ?*MultiQueue, + blockable: bool, +}; +pub extern fn time_watcher_init(loop: [*c]Loop, watcher: [*c]TimeWatcher, data: ?*anyopaque) void; +pub extern fn time_watcher_start(watcher: [*c]TimeWatcher, cb: time_cb, timeout: u64, repeat: u64) void; +pub extern fn time_watcher_stop(watcher: [*c]TimeWatcher) void; +pub extern fn time_watcher_close(watcher: [*c]TimeWatcher, cb: time_cb) void; +pub extern fn ex_ruby(eap: [*c]exarg_T) void; +pub extern fn ex_rubyfile(eap: [*c]exarg_T) void; +pub extern fn ex_rubydo(eap: [*c]exarg_T) void; +pub extern fn ex_python3(eap: [*c]exarg_T) void; +pub extern fn ex_py3file(eap: [*c]exarg_T) void; +pub extern fn ex_pydo3(eap: [*c]exarg_T) void; +pub extern fn ex_perl(eap: [*c]exarg_T) void; +pub extern fn ex_perlfile(eap: [*c]exarg_T) void; +pub extern fn ex_perldo(eap: [*c]exarg_T) void; +pub extern fn autowrite(buf: [*c]buf_T, forceit: c_int) c_int; +pub extern fn autowrite_all() void; +pub extern fn check_changed(buf: [*c]buf_T, flags: c_int) bool; +pub extern fn dialog_changed(buf: [*c]buf_T, checkall: bool) void; +pub extern fn dialog_close_terminal(buf: [*c]buf_T) bool; +pub extern fn can_abandon(buf: [*c]buf_T, forceit: c_int) bool; +pub extern fn check_changed_any(hidden: bool, unload: bool) bool; +pub extern fn check_fname() c_int; +pub extern fn buf_write_all(buf: [*c]buf_T, forceit: c_int) c_int; +pub extern fn ex_listdo(eap: [*c]exarg_T) void; +pub extern fn ex_compiler(eap: [*c]exarg_T) void; +pub extern fn ex_checktime(eap: [*c]exarg_T) void; +pub extern fn ex_drop(eap: [*c]exarg_T) void; +pub const save_state_T = extern struct { + save_msg_scroll: c_int, + save_restart_edit: c_int, + save_msg_didout: bool, + save_State: c_int, + save_finish_op: bool, + save_opcount: c_long, + save_reg_executing: c_int, + save_pending_end_reg_executing: bool, + tabuf: tasave_T, +}; +pub extern fn do_exmode() void; +pub extern fn do_cmdline_cmd(cmd: [*c]const u8) c_int; +pub extern fn do_cmdline(cmdline: [*c]u8, fgetline: LineGetter, cookie: ?*anyopaque, flags: c_int) c_int; +pub extern fn handle_did_throw() void; +pub extern fn getline_equal(fgetline: LineGetter, cookie: ?*anyopaque, func: LineGetter) bool; +pub extern fn getline_cookie(fgetline: LineGetter, cookie: ?*anyopaque) ?*anyopaque; +pub extern fn set_cmd_addr_type(eap: [*c]exarg_T, p: [*c]u8) void; +pub extern fn get_cmd_default_range(eap: [*c]exarg_T) linenr_T; +pub extern fn set_cmd_dflall_range(eap: [*c]exarg_T) void; +pub extern fn set_cmd_count(eap: [*c]exarg_T, count: linenr_T, validate: bool) void; +pub extern fn is_cmd_ni(cmdidx: cmdidx_T) bool; +pub extern fn parse_cmdline(cmdline: [*c]u8, eap: [*c]exarg_T, cmdinfo: [*c]CmdParseInfo, errormsg: [*c][*c]u8) bool; +pub extern fn execute_cmd(eap: [*c]exarg_T, cmdinfo: [*c]CmdParseInfo, preview: bool) c_int; +pub extern fn ex_errmsg(msg: [*c]const u8, arg: [*c]const u8) [*c]u8; +pub extern fn parse_command_modifiers(eap: [*c]exarg_T, errormsg: [*c][*c]u8, cmod: [*c]cmdmod_T, skip_only: bool) c_int; +pub extern fn undo_cmdmod(cmod: [*c]cmdmod_T) void; +pub extern fn parse_cmd_address(eap: [*c]exarg_T, errormsg: [*c][*c]u8, silent: bool) c_int; +pub extern fn checkforcmd(pp: [*c][*c]u8, cmd: [*c]const u8, len: c_int) bool; +pub extern fn find_ex_command(eap: [*c]exarg_T, full: [*c]c_int) [*c]u8; +pub extern fn modifier_len(cmd: [*c]u8) c_int; +pub extern fn cmd_exists(name: [*c]const u8) c_int; +pub extern fn f_fullcommand(argvars: [*c]typval_T, rettv: [*c]typval_T, fptr: EvalFuncData) void; +pub extern fn excmd_get_cmdidx(cmd: [*c]const u8, len: usize) cmdidx_T; +pub extern fn excmd_get_argt(idx: cmdidx_T) u32; +pub extern fn skip_range(cmd: [*c]const u8, ctx: [*c]c_int) [*c]u8; +pub extern fn ex_ni(eap: [*c]exarg_T) void; +pub extern fn invalid_range(eap: [*c]exarg_T) [*c]u8; +pub extern fn replace_makeprg(eap: [*c]exarg_T, arg: [*c]u8, cmdlinep: [*c][*c]u8) [*c]u8; +pub extern fn expand_filename(eap: [*c]exarg_T, cmdlinep: [*c][*c]u8, errormsgp: [*c][*c]u8) c_int; +pub extern fn separate_nextcmd(eap: [*c]exarg_T) void; +pub extern fn skip_cmd_arg(p: [*c]u8, rembs: c_int) [*c]u8; +pub extern fn get_bad_opt(p: [*c]const u8, eap: [*c]exarg_T) c_int; +pub extern fn ends_excmd(c: c_int) c_int; +pub extern fn find_nextcmd(p: [*c]const u8) [*c]u8; +pub extern fn check_nextcmd(p: [*c]u8) [*c]u8; +pub extern fn get_command_name(xp: [*c]expand_T, idx: c_int) [*c]u8; +pub extern fn not_exiting() void; +pub extern fn before_quit_autocmds(wp: [*c]win_T, quit_all: bool, forceit: bool) bool; +pub extern fn ex_win_close(forceit: c_int, win: [*c]win_T, tp: [*c]tabpage_T) void; +pub extern fn tabpage_close(forceit: c_int) void; +pub extern fn tabpage_close_other(tp: [*c]tabpage_T, forceit: c_int) void; +pub extern fn ex_splitview(eap: [*c]exarg_T) void; +pub extern fn tabpage_new() void; +pub extern fn do_exedit(eap: [*c]exarg_T, old_curwin: [*c]win_T) void; +pub extern fn changedir_func(new_dir: [*c]u8, scope: CdScope) bool; +pub extern fn ex_cd(eap: [*c]exarg_T) void; +pub extern fn do_sleep(msec: c_long) void; +pub extern fn ex_may_print(eap: [*c]exarg_T) void; +pub extern fn vim_mkdir_emsg(name: [*c]const u8, prot: c_int) c_int; +pub extern fn open_exfile(fname: [*c]u8, forceit: c_int, mode: [*c]u8) [*c]FILE; +pub extern fn update_topline_cursor() void; +pub extern fn save_current_state(sst: [*c]save_state_T) bool; +pub extern fn restore_current_state(sst: [*c]save_state_T) void; +pub extern fn expr_map_locked() bool; +pub extern fn exec_normal_cmd(cmd: [*c]u8, remap: c_int, silent: bool) void; +pub extern fn exec_normal(was_typed: bool) void; +pub extern fn find_cmdline_var(src: [*c]const u8, usedlen: [*c]usize) isize; +pub extern fn eval_vars(src: [*c]u8, srcstart: [*c]const u8, usedlen: [*c]usize, lnump: [*c]linenr_T, errormsg: [*c][*c]u8, escaped: [*c]c_int, empty_is_error: bool) [*c]u8; +pub extern fn expand_sfile(arg: [*c]u8) [*c]u8; +pub extern fn dialog_msg(buff: [*c]u8, format: [*c]u8, fname: [*c]u8) void; +pub extern fn filetype_plugin_enable() void; +pub extern fn filetype_maybe_enable() void; +pub extern fn set_no_hlsearch(flag: bool) void; +pub extern fn is_loclist_cmd(cmdidx: c_int) bool; +pub extern fn get_pressedreturn() bool; +pub extern fn set_pressedreturn(val: bool) void; +pub extern fn verify_command(cmd: [*c]u8) void; +pub extern fn get_cmd_argt(cmdidx: cmdidx_T) u32; +pub extern fn aborting() c_int; +pub extern fn update_force_abort() void; +pub extern fn should_abort(retcode: c_int) c_int; +pub extern fn aborted_in_try() c_int; +pub extern fn cause_errthrow(mesg: [*c]const u8, severe: bool, ignore: [*c]bool) bool; +pub extern fn free_global_msglist() void; +pub extern fn do_errthrow(cstack: [*c]cstack_T, cmdname: [*c]u8) void; +pub extern fn do_intthrow(cstack: [*c]cstack_T) c_int; +pub extern fn get_exception_string(value: ?*anyopaque, @"type": except_type_T, cmdname: [*c]u8, should_free: [*c]c_int) [*c]u8; +pub extern fn discard_current_exception() void; +pub extern fn report_make_pending(pending: c_int, value: ?*anyopaque) void; +pub extern fn report_resume_pending(pending: c_int, value: ?*anyopaque) void; +pub extern fn report_discard_pending(pending: c_int, value: ?*anyopaque) void; +pub extern fn ex_eval(eap: [*c]exarg_T) void; +pub extern fn ex_if(eap: [*c]exarg_T) void; +pub extern fn ex_endif(eap: [*c]exarg_T) void; +pub extern fn ex_else(eap: [*c]exarg_T) void; +pub extern fn ex_while(eap: [*c]exarg_T) void; +pub extern fn ex_continue(eap: [*c]exarg_T) void; +pub extern fn ex_break(eap: [*c]exarg_T) void; +pub extern fn ex_endwhile(eap: [*c]exarg_T) void; +pub extern fn ex_throw(eap: [*c]exarg_T) void; +pub extern fn do_throw(cstack: [*c]cstack_T) void; +pub extern fn ex_try(eap: [*c]exarg_T) void; +pub extern fn ex_catch(eap: [*c]exarg_T) void; +pub extern fn ex_finally(eap: [*c]exarg_T) void; +pub extern fn ex_endtry(eap: [*c]exarg_T) void; +pub extern fn enter_cleanup(csp: [*c]cleanup_T) void; +pub extern fn leave_cleanup(csp: [*c]cleanup_T) void; +pub extern fn cleanup_conditionals(cstack: [*c]cstack_T, searched_cond: c_int, inclusive: c_int) c_int; +pub extern fn rewind_conditionals(cstack: [*c]cstack_T, idx: c_int, cond_type: c_int, cond_level: [*c]c_int) void; +pub extern fn ex_endfunction(eap: [*c]exarg_T) void; +pub extern fn has_loop_cmd(p: [*c]u8) c_int; +pub extern fn ex_loadview(eap: [*c]exarg_T) void; +pub extern fn ex_mkrc(eap: [*c]exarg_T) void; +pub extern fn put_eol(fd: [*c]FILE) c_int; +pub extern fn put_line(fd: [*c]FILE, s: [*c]u8) c_int; +pub extern fn vim_findfile_init(path: [*c]u8, filename: [*c]u8, stopdirs: [*c]u8, level: c_int, free_visited: c_int, find_what: c_int, search_ctx_arg: ?*anyopaque, tagfile: c_int, rel_fname: [*c]u8) ?*anyopaque; +pub extern fn vim_findfile_stopdir(buf: [*c]u8) [*c]u8; +pub extern fn vim_findfile_cleanup(ctx: ?*anyopaque) void; +pub extern fn vim_findfile(search_ctx_arg: ?*anyopaque) [*c]u8; +pub extern fn vim_findfile_free_visited(search_ctx_arg: ?*anyopaque) void; +pub extern fn find_file_in_path(ptr: [*c]u8, len: usize, options: c_int, first: c_int, rel_fname: [*c]u8, file_to_find: [*c][*c]u8, search_ctx: [*c][*c]u8) [*c]u8; +pub extern fn find_directory_in_path(ptr: [*c]u8, len: usize, options: c_int, rel_fname: [*c]u8, file_to_find: [*c][*c]u8, search_ctx: [*c][*c]u8) [*c]u8; +pub extern fn find_file_in_path_option(ptr: [*c]u8, len: usize, options: c_int, first: c_int, path_option: [*c]u8, find_what: c_int, rel_fname: [*c]u8, suffixes: [*c]u8, file_to_find: [*c][*c]u8, search_ctx_arg: [*c][*c]u8) [*c]u8; +pub extern fn do_autocmd_dirchanged(new_dir: [*c]u8, scope: CdScope, cause: CdCause, pre: bool) void; +pub extern fn vim_chdirfile(fname: [*c]u8, cause: CdCause) c_int; +pub extern fn vim_chdir(new_dir: [*c]u8) c_int; +pub const kXDGNone: c_int = -1; +pub const kXDGConfigHome: c_int = 0; +pub const kXDGDataHome: c_int = 1; +pub const kXDGCacheHome: c_int = 2; +pub const kXDGStateHome: c_int = 3; +pub const kXDGRuntimeDir: c_int = 4; +pub const kXDGConfigDirs: c_int = 5; +pub const kXDGDataDirs: c_int = 6; +pub const XDGVarType = c_int; +pub extern fn os_getenv(name: [*c]const u8) [*c]const u8; +pub extern fn os_env_exists(name: [*c]const u8) bool; +pub extern fn os_setenv(name: [*c]const u8, value: [*c]const u8, overwrite: c_int) c_int; +pub extern fn os_unsetenv(name: [*c]const u8) c_int; +pub extern fn os_get_fullenv_size() usize; +pub extern fn os_free_fullenv(env: [*c][*c]u8) void; +pub extern fn os_copy_fullenv(env: [*c][*c]u8, env_size: usize) void; +pub extern fn os_getenvname_at_index(index: usize) [*c]u8; +pub extern fn os_get_pid() i64; +pub extern fn os_get_hostname(hostname: [*c]u8, size: usize) void; +pub extern fn init_homedir() void; +pub extern fn expand_env_save(src: [*c]u8) [*c]u8; +pub extern fn expand_env_save_opt(src: [*c]u8, one: bool) [*c]u8; +pub extern fn expand_env(src: [*c]u8, dst: [*c]u8, dstlen: c_int) void; +pub extern fn expand_env_esc(noalias srcp: [*c]u8, noalias dst: [*c]u8, dstlen: c_int, esc: bool, one: bool, prefix: [*c]u8) void; +pub extern fn vim_env_iter(delim: u8, val: [*c]const u8, iter: ?*const anyopaque, dir: [*c][*c]const u8, len: [*c]usize) ?*const anyopaque; +pub extern fn vim_env_iter_rev(delim: u8, val: [*c]const u8, iter: ?*const anyopaque, dir: [*c][*c]const u8, len: [*c]usize) ?*const anyopaque; +pub extern fn vim_get_prefix_from_exepath(exe_name: [*c]u8) void; +pub extern fn vim_getenv(name: [*c]const u8) [*c]u8; +pub extern fn home_replace(buf: [*c]const buf_T, src: [*c]const u8, dst: [*c]u8, dstlen: usize, one: bool) usize; +pub extern fn home_replace_save(buf: [*c]buf_T, src: [*c]const u8) [*c]u8; +pub extern fn get_env_name(xp: [*c]expand_T, idx: c_int) [*c]u8; +pub extern fn os_setenv_append_path(fname: [*c]const u8) bool; +pub extern fn os_shell_is_cmdexe(sh: [*c]const u8) bool; +pub extern fn vim_unsetenv_ext(@"var": [*c]const u8) void; +pub extern fn vim_setenv_ext(name: [*c]const u8, val: [*c]const u8) void; +pub extern fn fs_init() void; +pub extern fn fs_loop_lock() void; +pub extern fn fs_loop_unlock() void; +pub extern fn os_chdir(path: [*c]const u8) c_int; +pub extern fn os_dirname(buf: [*c]u8, len: usize) c_int; +pub extern fn os_isrealdir(name: [*c]const u8) bool; +pub extern fn os_isdir(name: [*c]const u8) bool; +pub extern fn os_nodetype(name: [*c]const u8) c_int; +pub extern fn os_exepath(buffer: [*c]u8, size: [*c]usize) c_int; +pub extern fn os_can_exe(name: [*c]const u8, abspath: [*c][*c]u8, use_path: bool) bool; +pub extern fn os_open(path: [*c]const u8, flags: c_int, mode: c_int) c_int; +pub extern fn os_fopen(path: [*c]const u8, flags: [*c]const u8) [*c]FILE; +pub extern fn os_set_cloexec(fd: c_int) c_int; +pub extern fn os_close(fd: c_int) c_int; +pub extern fn os_dup(fd: c_int) c_int; +pub extern fn os_read(fd: c_int, ret_eof: [*c]bool, ret_buf: [*c]u8, size: usize, non_blocking: bool) ptrdiff_t; +pub extern fn os_readv(fd: c_int, ret_eof: [*c]bool, iov: [*c]struct_iovec, iov_size: usize, non_blocking: bool) ptrdiff_t; +pub extern fn os_write(fd: c_int, buf: [*c]const u8, size: usize, non_blocking: bool) ptrdiff_t; +pub extern fn os_copy(path: [*c]const u8, new_path: [*c]const u8, flags: c_int) c_int; +pub extern fn os_fsync(fd: c_int) c_int; +pub extern fn os_getperm(name: [*c]const u8) i32; +pub extern fn os_setperm(name: [*c]const u8, perm: c_int) c_int; +pub extern fn os_get_acl(fname: [*c]const u8) vim_acl_T; +pub extern fn os_set_acl(fname: [*c]const u8, aclent: vim_acl_T) void; +pub extern fn os_free_acl(aclent: vim_acl_T) void; +pub extern fn os_file_owned(fname: [*c]const u8) bool; +pub extern fn os_chown(path: [*c]const u8, owner: uv_uid_t, group: uv_gid_t) c_int; +pub extern fn os_fchown(fd: c_int, owner: uv_uid_t, group: uv_gid_t) c_int; +pub extern fn os_path_exists(path: [*c]const u8) bool; +pub extern fn os_file_settime(path: [*c]const u8, atime: f64, mtime: f64) c_int; +pub extern fn os_file_is_readable(name: [*c]const u8) bool; +pub extern fn os_file_is_writable(name: [*c]const u8) c_int; +pub extern fn os_rename(path: [*c]const u8, new_path: [*c]const u8) c_int; +pub extern fn os_mkdir(path: [*c]const u8, mode: i32) c_int; +pub extern fn os_mkdir_recurse(dir: [*c]const u8, mode: i32, failed_dir: [*c][*c]u8, created: [*c][*c]u8) c_int; +pub extern fn os_file_mkdir(fname: [*c]u8, mode: i32) c_int; +pub extern fn os_mkdtemp(templ: [*c]const u8, path: [*c]u8) c_int; +pub extern fn os_rmdir(path: [*c]const u8) c_int; +pub extern fn os_scandir(dir: [*c]Directory, path: [*c]const u8) bool; +pub extern fn os_scandir_next(dir: [*c]Directory) [*c]const u8; +pub extern fn os_closedir(dir: [*c]Directory) void; +pub extern fn os_remove(path: [*c]const u8) c_int; +pub extern fn os_fileinfo(path: [*c]const u8, file_info: [*c]FileInfo) bool; +pub extern fn os_fileinfo_link(path: [*c]const u8, file_info: [*c]FileInfo) bool; +pub extern fn os_fileinfo_fd(file_descriptor: c_int, file_info: [*c]FileInfo) bool; +pub extern fn os_fileinfo_id_equal(file_info_1: [*c]const FileInfo, file_info_2: [*c]const FileInfo) bool; +pub extern fn os_fileinfo_id(file_info: [*c]const FileInfo, file_id: [*c]FileID) void; +pub extern fn os_fileinfo_inode(file_info: [*c]const FileInfo) u64; +pub extern fn os_fileinfo_size(file_info: [*c]const FileInfo) u64; +pub extern fn os_fileinfo_hardlinks(file_info: [*c]const FileInfo) u64; +pub extern fn os_fileinfo_blocksize(file_info: [*c]const FileInfo) u64; +pub extern fn os_fileid(path: [*c]const u8, file_id: [*c]FileID) bool; +pub extern fn os_fileid_equal(file_id_1: [*c]const FileID, file_id_2: [*c]const FileID) bool; +pub extern fn os_fileid_equal_fileinfo(file_id: [*c]const FileID, file_info: [*c]const FileInfo) bool; +pub extern fn os_realpath(name: [*c]const u8, buf: [*c]u8) [*c]u8; +pub extern fn os_get_total_mem_kib() u64; +pub extern fn get_appname() [*c]const u8; +pub extern fn stdpaths_get_xdg_var(idx: XDGVarType) [*c]u8; +pub extern fn get_xdg_home(idx: XDGVarType) [*c]u8; +pub extern fn stdpaths_user_cache_subpath(fname: [*c]const u8) [*c]u8; +pub extern fn stdpaths_user_conf_subpath(fname: [*c]const u8) [*c]u8; +pub extern fn stdpaths_user_data_subpath(fname: [*c]const u8) [*c]u8; +pub extern fn stdpaths_user_state_subpath(fname: [*c]const u8, trailing_pathseps: usize, escape_commas: bool) [*c]u8; +pub extern fn os_get_usernames(users: [*c]garray_T) c_int; +pub extern fn os_get_username(s: [*c]u8, len: usize) c_int; +pub extern fn os_get_uname(uid: uv_uid_t, s: [*c]u8, len: usize) c_int; +pub extern fn os_get_userdir(name: [*c]const u8) [*c]u8; +pub extern fn get_users(xp: [*c]expand_T, idx: c_int) [*c]u8; +pub extern fn match_user(name: [*c]u8) c_int; +pub const CheckItem = ?*const fn (?*anyopaque, [*c]const u8) callconv(.C) varnumber_T; +pub const FIO_LATIN1: c_int = 1; +pub const FIO_UTF8: c_int = 2; +pub const FIO_UCS2: c_int = 4; +pub const FIO_UCS4: c_int = 8; +pub const FIO_UTF16: c_int = 16; +pub const FIO_ENDIAN_L: c_int = 128; +pub const FIO_NOCONVERT: c_int = 8192; +pub const FIO_UCSBOM: c_int = 16384; +pub const FIO_ALL: c_int = -1; +const enum_unnamed_143 = c_int; +pub extern fn filemess(buf: [*c]buf_T, name: [*c]u8, s: [*c]u8, attr: c_int) void; +pub extern fn readfile(fname: [*c]u8, sfname: [*c]u8, from: linenr_T, lines_to_skip: linenr_T, lines_to_read: linenr_T, eap: [*c]exarg_T, flags: c_int, silent: bool) c_int; +pub extern fn prep_exarg(eap: [*c]exarg_T, buf: [*c]const buf_T) void; +pub extern fn set_file_options(set_options: c_int, eap: [*c]exarg_T) void; +pub extern fn set_forced_fenc(eap: [*c]exarg_T) void; +pub extern fn new_file_message() [*c]u8; +pub extern fn set_rw_fname(fname: [*c]u8, sfname: [*c]u8) c_int; +pub extern fn add_quoted_fname(ret_buf: [*c]u8, buf_len: usize, buf: [*c]const buf_T, fname: [*c]const u8) void; +pub extern fn msg_add_fileformat(eol_type: c_int) bool; +pub extern fn msg_add_lines(insert_space: c_int, lnum: c_long, nchars: off_T) void; +pub extern fn msg_add_eol() void; +pub extern fn time_differs(file_info: [*c]const FileInfo, mtime: c_long, mtime_ns: c_long) bool; +pub extern fn need_conversion(fenc: [*c]const u8) bool; +pub extern fn get_fio_flags(name: [*c]const u8) c_int; +pub extern fn shorten_buf_fname(buf: [*c]buf_T, dirname: [*c]u8, force: c_int) void; +pub extern fn shorten_fnames(force: c_int) void; +pub extern fn modname(fname: [*c]const u8, ext: [*c]const u8, prepend_dot: bool) [*c]u8; +pub extern fn vim_fgets(buf: [*c]u8, size: c_int, fp: [*c]FILE) bool; +pub extern fn get2c(fd: [*c]FILE) c_int; +pub extern fn get3c(fd: [*c]FILE) c_int; +pub extern fn get4c(fd: [*c]FILE) c_int; +pub extern fn get8ctime(fd: [*c]FILE) time_t; +pub extern fn read_string(fd: [*c]FILE, cnt: usize) [*c]u8; +pub extern fn put_bytes(fd: [*c]FILE, number: uintmax_t, len: usize) bool; +pub extern fn put_time(fd: [*c]FILE, time_: time_t) c_int; +pub extern fn vim_rename(from: [*c]const u8, to: [*c]const u8) c_int; +pub extern fn check_timestamps(focus: c_int) c_int; +pub extern fn buf_check_timestamp(buf: [*c]buf_T) c_int; +pub extern fn buf_reload(buf: [*c]buf_T, orig_mode: c_int, reload_options: bool) void; +pub extern fn buf_store_file_info(buf: [*c]buf_T, file_info: [*c]FileInfo) void; +pub extern fn write_lnum_adjust(offset: linenr_T) void; +pub extern fn readdir_core(gap: [*c]garray_T, path: [*c]const u8, context: ?*anyopaque, checkitem: CheckItem) c_int; +pub extern fn delete_recursive(name: [*c]const u8) c_int; +pub extern fn vim_deltempdir() void; +pub extern fn vim_gettempdir() [*c]u8; +pub extern fn vim_tempname() [*c]u8; +pub extern fn match_file_pat(pattern: [*c]u8, prog: [*c][*c]regprog_T, fname: [*c]u8, sfname: [*c]u8, tail: [*c]u8, allow_dirs: c_int) bool; +pub extern fn match_file_list(list: [*c]u8, sfname: [*c]u8, ffname: [*c]u8) bool; +pub extern fn file_pat_to_reg_pat(pat: [*c]const u8, pat_end: [*c]const u8, allow_dirs: [*c]u8, no_bslash: c_int) [*c]u8; +pub extern fn read_eintr(fd: c_int, buf: ?*anyopaque, bufsize: usize) c_long; +pub extern fn write_eintr(fd: c_int, buf: ?*anyopaque, bufsize: usize) c_long; +pub const FileDescriptor = extern struct { + fd: c_int, + _error: c_int, + rv: [*c]RBuffer, + wr: bool, + eof: bool, + non_blocking: bool, +}; +pub const kFileReadOnly: c_int = 1; +pub const kFileCreate: c_int = 2; +pub const kFileWriteOnly: c_int = 4; +pub const kFileNoSymlink: c_int = 8; +pub const kFileCreateOnly: c_int = 16; +pub const kFileTruncate: c_int = 32; +pub const kFileAppend: c_int = 64; +pub const kFileNonBlocking: c_int = 128; +pub const kFileMkDir: c_int = 256; +pub const FileOpenFlags = c_uint; +pub fn file_eof(fp: [*c]const FileDescriptor) callconv(.C) bool { + return (@as(c_int, @boolToInt(fp.*.eof)) != 0) and (rbuffer_size(fp.*.rv) == @bitCast(usize, @as(c_long, @as(c_int, 0)))); +} +pub fn file_fd(fp: [*c]const FileDescriptor) callconv(.C) c_int { + return fp.*.fd; +} +pub const kRWBufferSize: c_int = 1024; +const enum_unnamed_144 = c_uint; +pub extern fn file_open(ret_fp: [*c]FileDescriptor, fname: [*c]const u8, flags: c_int, mode: c_int) c_int; +pub extern fn file_open_fd(ret_fp: [*c]FileDescriptor, fd: c_int, flags: c_int) c_int; +pub extern fn file_open_new(@"error": [*c]c_int, fname: [*c]const u8, flags: c_int, mode: c_int) [*c]FileDescriptor; +pub extern fn file_open_fd_new(@"error": [*c]c_int, fd: c_int, flags: c_int) [*c]FileDescriptor; +pub extern fn file_open_stdin() [*c]FileDescriptor; +pub extern fn file_close(fp: [*c]FileDescriptor, do_fsync: bool) c_int; +pub extern fn file_free(fp: [*c]FileDescriptor, do_fsync: bool) c_int; +pub extern fn file_flush(fp: [*c]FileDescriptor) c_int; +pub extern fn file_fsync(fp: [*c]FileDescriptor) c_int; +pub extern fn file_read(fp: [*c]FileDescriptor, ret_buf: [*c]u8, size: usize) ptrdiff_t; +pub extern fn file_write(fp: [*c]FileDescriptor, buf: [*c]const u8, size: usize) ptrdiff_t; +pub extern fn file_skip(fp: [*c]FileDescriptor, size: usize) ptrdiff_t; +pub extern fn msgpack_file_write(data: ?*anyopaque, buf: [*c]const u8, len: usize) c_int; +pub extern fn msgpack_file_write_error(@"error": c_int) c_int; +pub const REMAP_YES: c_int = 0; +pub const REMAP_NONE: c_int = -1; +pub const REMAP_SCRIPT: c_int = -2; +pub const REMAP_SKIP: c_int = -3; +pub const enum_RemapValues = c_int; +pub const FLUSH_MINIMAL: c_int = 0; +pub const FLUSH_TYPEAHEAD: c_int = 1; +pub const FLUSH_INPUT: c_int = 2; +pub const flush_buffers_T = c_uint; +pub const NSCRIPT: c_int = 15; +const enum_unnamed_145 = c_uint; +pub extern var scriptin: [15][*c]FileDescriptor; +pub extern fn free_buff(buf: [*c]buffheader_T) void; +pub extern fn get_recorded() [*c]u8; +pub extern fn get_inserted() [*c]u8; +pub extern fn stuff_empty() c_int; +pub extern fn readbuf1_empty() c_int; +pub extern fn typeahead_noflush(c: c_int) void; +pub extern fn flush_buffers(flush_typeahead: flush_buffers_T) void; +pub extern fn beep_flush() void; +pub extern fn ResetRedobuff() void; +pub extern fn CancelRedo() void; +pub extern fn saveRedobuff(save_redo: [*c]save_redo_T) void; +pub extern fn restoreRedobuff(save_redo: [*c]save_redo_T) void; +pub extern fn AppendToRedobuff(s: [*c]const u8) void; +pub extern fn AppendToRedobuffLit(str: [*c]const u8, len: c_int) void; +pub extern fn AppendCharToRedobuff(c: c_int) void; +pub extern fn AppendNumberToRedobuff(n: c_long) void; +pub extern fn stuffReadbuff(s: [*c]const u8) void; +pub extern fn stuffRedoReadbuff(s: [*c]const u8) void; +pub extern fn stuffReadbuffLen(s: [*c]const u8, len: ptrdiff_t) void; +pub extern fn stuffReadbuffSpec(s: [*c]const u8) void; +pub extern fn stuffcharReadbuff(c: c_int) void; +pub extern fn stuffnumReadbuff(n: c_long) void; +pub extern fn stuffescaped(arg: [*c]const u8, literally: bool) void; +pub extern fn start_redo(count: c_long, old_redo: bool) c_int; +pub extern fn start_redo_ins() c_int; +pub extern fn stop_redo_ins() void; +pub extern fn noremap_keys() bool; +pub extern fn ins_typebuf(str: [*c]u8, noremap: c_int, offset: c_int, nottyped: bool, silent: bool) c_int; +pub extern fn ins_char_typebuf(c: c_int, modifiers: c_int) c_int; +pub extern fn typebuf_changed(tb_change_cnt: c_int) bool; +pub extern fn typebuf_typed() c_int; +pub extern fn typebuf_maplen() c_int; +pub extern fn del_typebuf(len: c_int, offset: c_int) void; +pub extern fn ungetchars(len: c_int) void; +pub extern fn may_sync_undo() void; +pub extern fn alloc_typebuf() void; +pub extern fn free_typebuf() void; +pub extern fn save_typebuf() void; +pub extern fn save_typeahead(tp: [*c]tasave_T) void; +pub extern fn restore_typeahead(tp: [*c]tasave_T) void; +pub extern fn openscript(name: [*c]u8, directly: bool) void; +pub extern fn using_script() c_int; +pub extern fn before_blocking() void; +pub extern fn merge_modifiers(c_arg: c_int, modifiers: [*c]c_int) c_int; +pub extern fn vgetc() c_int; +pub extern fn safe_vgetc() c_int; +pub extern fn plain_vgetc() c_int; +pub extern fn vpeekc() c_int; +pub extern fn vpeekc_any() c_int; +pub extern fn char_avail() c_int; +pub extern fn f_getchar(argvars: [*c]typval_T, rettv: [*c]typval_T, fptr: EvalFuncData) void; +pub extern fn f_getcharstr(argvars: [*c]typval_T, rettv: [*c]typval_T, fptr: EvalFuncData) void; +pub extern fn f_getcharmod(argvars: [*c]typval_T, rettv: [*c]typval_T, fptr: EvalFuncData) void; +pub extern fn vungetc(c: c_int) void; +pub extern fn check_end_reg_executing(advance: bool) void; +pub extern fn inchar(buf: [*c]u8, maxlen: c_int, wait_time: c_long) c_int; +pub extern fn fix_input_buffer(buf: [*c]u8, len: c_int) c_int; +pub extern fn getcmdkeycmd(promptc: c_int, cookie: ?*anyopaque, indent: c_int, do_concat: bool) [*c]u8; +pub extern fn map_execute_lua() bool; +pub extern var default_grid: ScreenGrid; +pub extern var resizing_screen: bool; +pub extern var linebuf_char: [*c]schar_T; +pub extern var linebuf_attr: [*c]sattr_T; +pub fn schar_from_ascii(arg_p: [*c]u8, c: u8) callconv(.C) void { + var p = arg_p; + p[@intCast(c_uint, @as(c_int, 0))] = c; + p[@intCast(c_uint, @as(c_int, 1))] = 0; +} +pub fn schar_from_char(arg_p: [*c]u8, arg_c: c_int) callconv(.C) c_int { + var p = arg_p; + var c = arg_c; + var len: c_int = utf_char2bytes(c, p); + (blk: { + const tmp = len; + if (tmp >= 0) break :blk p + @intCast(usize, tmp) else break :blk p - ~@bitCast(usize, @intCast(isize, tmp) +% -1); + }).* = '\x00'; + return len; +} +pub fn schar_cmp(arg_sc1: [*c]u8, arg_sc2: [*c]u8) callconv(.C) c_int { + var sc1 = arg_sc1; + var sc2 = arg_sc2; + return strncmp(sc1, sc2, @sizeOf(schar_T)); +} +pub fn schar_copy(arg_sc1: [*c]u8, arg_sc2: [*c]u8) callconv(.C) void { + var sc1 = arg_sc1; + var sc2 = arg_sc2; + _ = xstrlcpy(sc1, sc2, @sizeOf(schar_T)); +} +pub extern fn grid_adjust(grid: [*c][*c]ScreenGrid, row_off: [*c]c_int, col_off: [*c]c_int) void; +pub extern fn schar_from_cc(p: [*c]u8, c: c_int, u8cc: [*c]c_int) c_int; +pub extern fn grid_clear_line(grid: [*c]ScreenGrid, off: usize, width: c_int, valid: bool) void; +pub extern fn grid_invalidate(grid: [*c]ScreenGrid) void; +pub extern fn grid_invalid_row(grid: [*c]ScreenGrid, row: c_int) bool; +pub extern fn grid_lefthalve(grid: [*c]ScreenGrid, row: c_int, col: c_int) bool; +pub extern fn grid_fix_col(grid: [*c]ScreenGrid, col: c_int, row: c_int) c_int; +pub extern fn grid_putchar(grid: [*c]ScreenGrid, c: c_int, row: c_int, col: c_int, attr: c_int) void; +pub extern fn grid_getbytes(grid: [*c]ScreenGrid, row: c_int, col: c_int, bytes: [*c]u8, attrp: [*c]c_int) void; +pub extern fn grid_puts(grid: [*c]ScreenGrid, text: [*c]u8, row: c_int, col: c_int, attr: c_int) c_int; +pub extern fn grid_puts_line_start(grid: [*c]ScreenGrid, row: c_int) void; +pub extern fn grid_put_schar(grid: [*c]ScreenGrid, row: c_int, col: c_int, schar: [*c]u8, attr: c_int) void; +pub extern fn grid_puts_len(grid: [*c]ScreenGrid, text: [*c]const u8, textlen: c_int, row: c_int, col: c_int, attr: c_int) c_int; +pub extern fn grid_puts_line_flush(set_cursor: bool) void; +pub extern fn grid_fill(grid: [*c]ScreenGrid, start_row: c_int, end_row: c_int, start_col: c_int, end_col: c_int, c1: c_int, c2: c_int, attr: c_int) void; +pub extern fn grid_put_linebuf(grid: [*c]ScreenGrid, row: c_int, coloff: c_int, endcol: c_int, clear_width: c_int, rlflag: c_int, wp: [*c]win_T, bg_attr: c_int, wrap: bool) void; +pub extern fn grid_alloc(grid: [*c]ScreenGrid, rows: c_int, columns: c_int, copy: bool, valid: bool) void; +pub extern fn grid_free(grid: [*c]ScreenGrid) void; +pub extern fn grid_free_all_mem() void; +pub extern fn win_grid_alloc(wp: [*c]win_T) void; +pub extern fn grid_assign_handle(grid: [*c]ScreenGrid) void; +pub extern fn grid_ins_lines(grid: [*c]ScreenGrid, row: c_int, line_count: c_int, end: c_int, col: c_int, width: c_int) void; +pub extern fn grid_del_lines(grid: [*c]ScreenGrid, row: c_int, line_count: c_int, end: c_int, col: c_int, width: c_int) void; +pub extern fn get_win_by_grid_handle(handle: handle_T) [*c]win_T; +pub extern fn ex_help(eap: [*c]exarg_T) void; +pub extern fn ex_helpclose(eap: [*c]exarg_T) void; +pub extern fn check_help_lang(arg: [*c]u8) [*c]u8; +pub extern fn help_heuristic(matched_string: [*c]u8, offset: c_int, wrong_case: c_int) c_int; +pub extern fn find_help_tags(arg: [*c]const u8, num_matches: [*c]c_int, matches: [*c][*c][*c]u8, keep_lang: bool) c_int; +pub extern fn cleanup_help_tags(num_file: c_int, file: [*c][*c]u8) void; +pub extern fn prepare_help_buffer() void; +pub extern fn fix_help_buffer() void; +pub extern fn ex_exusage(eap: [*c]exarg_T) void; +pub extern fn ex_viusage(eap: [*c]exarg_T) void; +pub extern fn ex_helptags(eap: [*c]exarg_T) void; +pub extern fn highlight_init() void; +pub extern fn highlight_use_hlstate() bool; +pub extern fn ui_send_all_hls(ui: [*c]UI) void; +pub extern fn hl_get_syn_attr(ns_id: c_int, idx: c_int, at_en: HlAttrs) c_int; +pub extern fn ns_hl_def(ns_id: NS, hl_id: c_int, attrs: HlAttrs, link_id: c_int, dict: [*c]KeyDict_highlight) void; +pub extern fn ns_get_hl(ns_hl: [*c]NS, hl_id: c_int, link: bool, nodefault: bool) c_int; +pub extern fn hl_check_ns() bool; +pub extern fn win_check_ns_hl(wp: [*c]win_T) bool; +pub extern fn hl_get_ui_attr(ns_id: c_int, idx: c_int, final_id: c_int, optional: bool) c_int; +pub extern fn update_window_hl(wp: [*c]win_T, invalid: bool) void; +pub extern fn update_ns_hl(ns_id: c_int) void; +pub extern fn win_bg_attr(wp: [*c]win_T) c_int; +pub extern fn hl_get_underline() c_int; +pub extern fn hl_get_term_attr(aep: [*c]HlAttrs) c_int; +pub extern fn clear_hl_tables(reinit: bool) void; +pub extern fn hl_invalidate_blends() void; +pub extern fn hl_combine_attr(char_attr: c_int, prim_attr: c_int) c_int; +pub extern fn hl_blend_attrs(back_attr: c_int, front_attr: c_int, through: [*c]bool) c_int; +pub extern fn syn_attr2entry(attr: c_int) HlAttrs; +pub extern fn hl_get_attr_by_id(attr_id: Integer, rgb: Boolean, arena: [*c]Arena, err: [*c]Error) Dictionary; +pub extern fn hlattrs2dict(hl: [*c]Dictionary, hl_attrs: [*c]Dictionary, ae: HlAttrs, use_rgb: bool, short_keys: bool) void; +pub extern fn dict2hlattrs(dict: [*c]KeyDict_highlight, use_rgb: bool, link_id: [*c]c_int, err: [*c]Error) HlAttrs; +pub extern fn object_to_color(val: Object, key: [*c]u8, rgb: bool, err: [*c]Error) c_int; +pub extern fn hl_inspect(attr: c_int) Array; +pub fn win_hl_attr(arg_wp: [*c]win_T, arg_hlf: c_int) callconv(.C) c_int { + var wp = arg_wp; + var hlf = arg_hlf; + return (blk: { + const tmp = hlf; + if (tmp >= 0) break :blk (if ((wp.*.w_ns_hl_attr != null) and (ns_hl_fast < @as(c_int, 0))) wp.*.w_ns_hl_attr else hl_attr_active) + @intCast(usize, tmp) else break :blk (if ((wp.*.w_ns_hl_attr != null) and (ns_hl_fast < @as(c_int, 0))) wp.*.w_ns_hl_attr else hl_attr_active) - ~@bitCast(usize, @intCast(isize, tmp) +% -1); + }).*; +} +pub extern var buffer_handles: Map_handle_T_ptr_t; +pub extern var window_handles: Map_handle_T_ptr_t; +pub extern var tabpage_handles: Map_handle_T_ptr_t; +pub const TryState = extern struct { + current_exception: [*c]except_T, + private_msg_list: [*c]msglist_T, + msg_list: [*c]const [*c]const msglist_T, + trylevel: c_int, + got_int: c_int, + did_throw: bool, + need_rethrow: c_int, + did_emsg: c_int, +}; +pub extern fn try_enter(tstate: [*c]TryState) void; +pub extern fn try_leave(tstate: [*c]const TryState, err: [*c]Error) bool; +pub extern fn try_start() void; +pub extern fn try_end(err: [*c]Error) bool; +pub extern fn dict_get_value(dict: [*c]dict_T, key: String, err: [*c]Error) Object; +pub extern fn dict_check_writable(dict: [*c]dict_T, key: String, del: bool, err: [*c]Error) [*c]dictitem_T; +pub extern fn dict_set_var(dict: [*c]dict_T, key: String, value: Object, del: bool, retval: bool, err: [*c]Error) Object; +pub extern fn find_buffer_by_handle(buffer: Buffer, err: [*c]Error) [*c]buf_T; +pub extern fn find_window_by_handle(window: Window, err: [*c]Error) [*c]win_T; +pub extern fn find_tab_by_handle(tabpage: Tabpage, err: [*c]Error) [*c]tabpage_T; +pub extern fn cchar_to_string(c: u8) String; +pub extern fn cstr_to_string(str: [*c]const u8) String; +pub extern fn string_to_cstr(str: String) [*c]u8; +pub extern fn cbuf_to_string(buf: [*c]const u8, size: usize) String; +pub extern fn cstrn_to_string(str: [*c]const u8, maxsize: usize) String; +pub extern fn cstrn_as_string(str: [*c]u8, maxsize: usize) String; +pub extern fn cstr_as_string(str: [*c]u8) String; +pub extern fn ga_take_string(ga: [*c]garray_T) String; +pub extern fn string_to_array(input: String, crlf: bool) Array; +pub extern fn buf_get_text(buf: [*c]buf_T, lnum: i64, start_col: i64, end_col: i64, err: [*c]Error) String; +pub extern fn api_free_string(value: String) void; +pub extern fn arena_array(arena: [*c]Arena, max_size: usize) Array; +pub extern fn arena_dict(arena: [*c]Arena, max_size: usize) Dictionary; +pub extern fn arena_string(arena: [*c]Arena, str: String) String; +pub extern fn api_free_object(value: Object) void; +pub extern fn api_free_array(value: Array) void; +pub extern fn api_free_dictionary(value: Dictionary) void; +pub extern fn api_clear_error(value: [*c]Error) void; +pub extern fn api_metadata() Dictionary; +pub extern fn copy_string(str: String, arena: [*c]Arena) String; +pub extern fn copy_array(array: Array, arena: [*c]Arena) Array; +pub extern fn copy_dictionary(dict: Dictionary, arena: [*c]Arena) Dictionary; +pub extern fn copy_object(obj: Object, arena: [*c]Arena) Object; +pub extern fn api_set_error(err: [*c]Error, errType: ErrorType, format: [*c]const u8, ...) void; +pub extern fn api_object_to_bool(obj: Object, what: [*c]const u8, nil_value: bool, err: [*c]Error) bool; +pub extern fn object_to_hl_id(obj: Object, what: [*c]const u8, err: [*c]Error) c_int; +pub extern fn api_typename(t: ObjectType) [*c]u8; +pub extern fn parse_hl_msg(chunks: Array, err: [*c]Error) HlMessage; +pub extern fn api_dict_to_keydict(rv: ?*anyopaque, hashy: field_hash, dict: Dictionary, err: [*c]Error) bool; +pub extern fn api_free_keydict(dict: ?*anyopaque, table: [*c]KeySetLink) void; +pub extern fn set_mark(buf: [*c]buf_T, name: String, line: Integer, col: Integer, err: [*c]Error) bool; +pub extern fn get_default_stl_hl(wp: [*c]win_T, use_winbar: bool, stc_hl_id: c_int) [*c]const u8; +pub extern fn find_sid(channel_id: u64) c_int; +pub extern fn api_set_sctx(channel_id: u64) sctx_T; +pub const color_name_table_T = extern struct { + name: [*c]u8, + color: RgbValue, +}; +pub const color_name_table: [*c]color_name_table_T = @extern([*c]color_name_table_T, .{ + .name = "color_name_table", +}); +pub extern fn highlight_num_groups() c_int; +pub extern fn highlight_group_name(id: c_int) [*c]u8; +pub extern fn highlight_link_id(id: c_int) c_int; +pub extern fn syn_init_cmdline_highlight(reset: bool, init: bool) void; +pub extern fn init_highlight(both: bool, reset: bool) void; +pub extern fn load_colors(name: [*c]u8) c_int; +pub extern fn lookup_color(idx: c_int, foreground: bool, boldp: [*c]TriState) c_int; +pub extern fn set_hl_group(id: c_int, attrs: HlAttrs, dict: [*c]KeyDict_highlight, link_id: c_int) void; +pub extern fn do_highlight(line: [*c]const u8, forceit: bool, init: bool) void; +pub extern fn restore_cterm_colors() void; +pub extern fn ns_get_hl_defs(ns_id: NS, opts: [*c]KeyDict_get_highlight, arena: [*c]Arena, err: [*c]Error) Dictionary; +pub extern fn highlight_has_attr(id: c_int, flag: c_int, modec: c_int) [*c]const u8; +pub extern fn highlight_color(id: c_int, what: [*c]const u8, modec: c_int) [*c]const u8; +pub extern fn syn_list_header(did_header: bool, outlen: c_int, id: c_int, force_newline: bool) bool; +pub extern fn syn_name2id(name: [*c]const u8) c_int; +pub extern fn syn_name2id_len(name: [*c]const u8, len: usize) c_int; +pub extern fn syn_name2attr(name: [*c]const u8) c_int; +pub extern fn highlight_exists(name: [*c]const u8) c_int; +pub extern fn syn_id2name(id: c_int) [*c]u8; +pub extern fn syn_check_group(name: [*c]const u8, len: usize) c_int; +pub extern fn syn_id2attr(hl_id: c_int) c_int; +pub extern fn syn_ns_id2attr(ns_id: c_int, hl_id: c_int, optional: [*c]bool) c_int; +pub extern fn syn_get_final_id(hl_id: c_int) c_int; +pub extern fn syn_ns_get_final_id(ns_id: [*c]c_int, hl_idp: [*c]c_int) bool; +pub extern fn highlight_attr_set_all() void; +pub extern fn highlight_changed() void; +pub extern fn set_context_in_highlight_cmd(xp: [*c]expand_T, arg: [*c]const u8) void; +pub extern fn get_highlight_name(xp: [*c]expand_T, idx: c_int) [*c]const u8; +pub extern fn get_highlight_name_ext(xp: [*c]expand_T, idx: c_int, skip_cleared: bool) [*c]const u8; +pub extern fn name_to_color(name: [*c]const u8, idx: [*c]c_int) RgbValue; +pub extern fn coloridx_to_name(idx: c_int, val: c_int, hexbuf: [*c]u8) [*c]const u8; +pub extern fn name_to_ctermcolor(name: [*c]const u8) c_int; +pub const IndentGetter = ?*const fn () callconv(.C) c_int; +pub extern fn tabstop_set(@"var": [*c]u8, array: [*c][*c]c_long) bool; +pub extern fn tabstop_padding(col: colnr_T, ts_arg: c_long, vts: [*c]const c_long) c_int; +pub extern fn tabstop_at(col: colnr_T, ts: c_long, vts: [*c]const c_long) c_int; +pub extern fn tabstop_start(col: colnr_T, ts: c_long, vts: [*c]c_long) colnr_T; +pub extern fn tabstop_fromto(start_col: colnr_T, end_col: colnr_T, ts_arg: c_long, vts: [*c]const c_long, ntabs: [*c]c_int, nspcs: [*c]c_int) void; +pub extern fn tabstop_eq(ts1: [*c]const c_long, ts2: [*c]const c_long) bool; +pub extern fn tabstop_copy(oldts: [*c]const c_long) [*c]c_int; +pub extern fn tabstop_count(ts: [*c]c_long) c_int; +pub extern fn tabstop_first(ts: [*c]c_long) c_int; +pub extern fn get_sw_value(buf: [*c]buf_T) c_int; +pub extern fn get_sw_value_pos(buf: [*c]buf_T, pos: [*c]pos_T) c_long; +pub extern fn get_sw_value_indent(buf: [*c]buf_T) c_long; +pub extern fn get_sw_value_col(buf: [*c]buf_T, col: colnr_T) c_long; +pub extern fn get_sts_value() c_int; +pub extern fn get_indent() c_int; +pub extern fn get_indent_lnum(lnum: linenr_T) c_int; +pub extern fn get_indent_buf(buf: [*c]buf_T, lnum: linenr_T) c_int; +pub extern fn get_indent_str(ptr: [*c]const u8, ts: c_int, list: bool) c_int; +pub extern fn get_indent_str_vtab(ptr: [*c]const u8, ts: c_long, vts: [*c]c_long, list: bool) c_int; +pub extern fn set_indent(size: c_int, flags: c_int) c_int; +pub extern fn get_number_indent(lnum: linenr_T) c_int; +pub extern fn briopt_check(wp: [*c]win_T) bool; +pub extern fn get_breakindent_win(wp: [*c]win_T, line: [*c]u8) c_int; +pub extern fn inindent(extra: c_int) c_int; +pub extern fn may_do_si() bool; +pub extern fn ex_retab(eap: [*c]exarg_T) void; +pub extern fn get_expr_indent() c_int; +pub extern fn get_lisp_indent() c_int; +pub extern fn fixthisline(get_the_indent: IndentGetter) void; +pub extern fn use_indentexpr_for_lisp() bool; +pub extern fn fix_indent() void; +pub extern fn find_start_comment(ind_maxcomment: c_int) [*c]pos_T; +pub extern fn is_pos_in_string(line: [*c]const u8, col: colnr_T) c_int; +pub extern fn cin_is_cinword(line: [*c]const u8) bool; +pub extern fn cin_islabel() bool; +pub extern fn cin_iscase(s: [*c]const u8, strict: bool) bool; +pub extern fn cin_isscopedecl(p: [*c]const u8) bool; +pub extern fn parse_cino(buf: [*c]buf_T) void; +pub extern fn get_c_indent() c_int; +pub extern fn do_c_expr_indent() void; +pub extern fn ask_yesno(str: [*c]const u8, direct: bool) c_int; +pub extern fn get_keystroke(events: ?*MultiQueue) c_int; +pub extern fn get_number(colon: c_int, mouse_used: [*c]c_int) c_int; +pub extern fn prompt_for_number(mouse_used: [*c]c_int) c_int; +pub extern fn ins_ctrl_x() void; +pub extern fn ctrl_x_mode_none() bool; +pub extern fn ctrl_x_mode_normal() bool; +pub extern fn ctrl_x_mode_scroll() bool; +pub extern fn ctrl_x_mode_whole_line() bool; +pub extern fn ctrl_x_mode_files() bool; +pub extern fn ctrl_x_mode_tags() bool; +pub extern fn ctrl_x_mode_path_patterns() bool; +pub extern fn ctrl_x_mode_path_defines() bool; +pub extern fn ctrl_x_mode_dictionary() bool; +pub extern fn ctrl_x_mode_thesaurus() bool; +pub extern fn ctrl_x_mode_cmdline() bool; +pub extern fn ctrl_x_mode_function() bool; +pub extern fn ctrl_x_mode_omni() bool; +pub extern fn ctrl_x_mode_spell() bool; +pub extern fn ctrl_x_mode_line_or_eval() bool; +pub extern fn ctrl_x_mode_not_default() bool; +pub extern fn ctrl_x_mode_not_defined_yet() bool; +pub extern fn compl_status_adding() bool; +pub extern fn compl_status_sol() bool; +pub extern fn compl_status_local() bool; +pub extern fn compl_status_clear() void; +pub extern fn check_compl_option(dict_opt: bool) bool; +pub extern fn vim_is_ctrl_x_key(c: c_int) bool; +pub extern fn ins_compl_accept_char(c: c_int) bool; +pub extern fn ins_compl_add_infercase(str_arg: [*c]u8, len: c_int, icase: bool, fname: [*c]u8, dir: Direction, cont_s_ipos: bool) c_int; +pub extern fn ins_compl_has_shown_match() bool; +pub extern fn ins_compl_long_shown_match() bool; +pub extern fn completeopt_was_set() void; +pub extern fn pum_wanted() bool; +pub extern fn ins_compl_show_pum() void; +pub extern fn find_word_start(ptr: [*c]u8) [*c]u8; +pub extern fn find_word_end(ptr: [*c]u8) [*c]u8; +pub extern fn ins_compl_clear() void; +pub extern fn ins_compl_active() bool; +pub extern fn ins_compl_used_match() bool; +pub extern fn ins_compl_init_get_longest() void; +pub extern fn ins_compl_interrupted() bool; +pub extern fn ins_compl_enter_selects() bool; +pub extern fn ins_compl_col() colnr_T; +pub extern fn ins_compl_len() c_int; +pub extern fn ins_compl_bs() c_int; +pub extern fn ins_compl_addleader(c: c_int) void; +pub extern fn ins_compl_addfrommatch() void; +pub extern fn ins_compl_prep(c: c_int) bool; +pub extern fn set_completefunc_option(errmsg: [*c][*c]const u8) void; +pub extern fn set_buflocal_cfu_callback(buf: [*c]buf_T) void; +pub extern fn set_omnifunc_option(buf: [*c]buf_T, errmsg: [*c][*c]const u8) void; +pub extern fn set_buflocal_ofu_callback(buf: [*c]buf_T) void; +pub extern fn set_thesaurusfunc_option(errmsg: [*c][*c]const u8) void; +pub extern fn set_ref_in_insexpand_funcs(copyID: c_int) bool; +pub extern fn f_complete(argvars: [*c]typval_T, rettv: [*c]typval_T, fptr: EvalFuncData) void; +pub extern fn f_complete_add(argvars: [*c]typval_T, rettv: [*c]typval_T, fptr: EvalFuncData) void; +pub extern fn f_complete_check(argvars: [*c]typval_T, rettv: [*c]typval_T, fptr: EvalFuncData) void; +pub extern fn f_complete_info(argvars: [*c]typval_T, rettv: [*c]typval_T, fptr: EvalFuncData) void; +pub extern fn ins_compl_delete() void; +pub extern fn ins_compl_insert(in_compl_func: bool) void; +pub extern fn ins_compl_check_keys(frequency: c_int, in_compl_func: bool) void; +pub extern fn ins_complete(c: c_int, enable_pum: bool) c_int; +pub extern fn fastforward_buf_to_lnum(s: [*c][*c]const u8, lnum: c_long) void; +pub extern fn linematch_nbuffers(diff_blk: [*c][*c]const u8, diff_len: [*c]const c_int, ndiffs: usize, decisions: [*c][*c]c_int, iwhite: bool) usize; +pub extern fn nlua_pop_typval(lstate: ?*lua_State, ret_tv: [*c]typval_T) bool; +pub extern fn nlua_push_typval(lstate: ?*lua_State, tv: [*c]typval_T, special: bool) bool; +pub extern fn nlua_push_String(lstate: ?*lua_State, s: String, special: bool) void; +pub extern fn nlua_push_Integer(lstate: ?*lua_State, n: Integer, special: bool) void; +pub extern fn nlua_push_Float(lstate: ?*lua_State, f: Float, special: bool) void; +pub extern fn nlua_push_Boolean(lstate: ?*lua_State, b: Boolean, special: bool) void; +pub extern fn nlua_push_Dictionary(lstate: ?*lua_State, dict: Dictionary, special: bool) void; +pub extern fn nlua_push_Array(lstate: ?*lua_State, array: Array, special: bool) void; +pub extern fn nlua_push_Buffer(lstate: ?*lua_State, item: Buffer, special: bool) void; +pub extern fn nlua_push_Window(lstate: ?*lua_State, item: Window, special: bool) void; +pub extern fn nlua_push_Tabpage(lstate: ?*lua_State, item: Tabpage, special: bool) void; +pub extern fn nlua_push_Object(lstate: ?*lua_State, obj: Object, special: bool) void; +pub extern fn nlua_pop_String(lstate: ?*lua_State, err: [*c]Error) String; +pub extern fn nlua_pop_Integer(lstate: ?*lua_State, err: [*c]Error) Integer; +pub extern fn nlua_pop_Boolean(lstate: ?*lua_State, err: [*c]Error) Boolean; +pub extern fn nlua_pop_Float(lstate: ?*lua_State, err: [*c]Error) Float; +pub extern fn nlua_pop_Array(lstate: ?*lua_State, err: [*c]Error) Array; +pub extern fn nlua_pop_Dictionary(lstate: ?*lua_State, ref: bool, err: [*c]Error) Dictionary; +pub extern fn nlua_pop_Object(lstate: ?*lua_State, ref: bool, err: [*c]Error) Object; +pub extern fn nlua_pop_LuaRef(lstate: ?*lua_State, err: [*c]Error) LuaRef; +pub extern fn nlua_pop_Buffer(lstate: ?*lua_State, err: [*c]Error) Buffer; +pub extern fn nlua_pop_Window(lstate: ?*lua_State, err: [*c]Error) Window; +pub extern fn nlua_pop_Tabpage(lstate: ?*lua_State, err: [*c]Error) Tabpage; +pub extern fn nlua_init_types(lstate: ?*lua_State) void; +pub extern fn nlua_pop_keydict(L: ?*lua_State, retval: ?*anyopaque, hashy: field_hash, err: [*c]Error) void; +pub const struct_ucmd = extern struct { + uc_name: [*c]u8, + uc_argt: u32, + uc_rep: [*c]u8, + uc_def: i64, + uc_compl: c_int, + uc_addr_type: cmd_addr_T, + uc_script_ctx: sctx_T, + uc_compl_arg: [*c]u8, + uc_compl_luaref: LuaRef, + uc_preview_luaref: LuaRef, + uc_luaref: LuaRef, +}; +pub const ucmd_T = struct_ucmd; +pub extern var ucmds: garray_T; +pub extern fn find_ucmd(eap: [*c]exarg_T, p: [*c]u8, full: [*c]c_int, xp: [*c]expand_T, complp: [*c]c_int) [*c]u8; +pub extern fn set_context_in_user_cmd(xp: [*c]expand_T, arg_in: [*c]const u8) [*c]const u8; +pub extern fn set_context_in_user_cmdarg(cmd: [*c]const u8, arg: [*c]const u8, argt: u32, context: c_int, xp: [*c]expand_T, forceit: bool) [*c]const u8; +pub extern fn expand_user_command_name(idx: c_int) [*c]u8; +pub extern fn get_user_commands(xp: [*c]expand_T, idx: c_int) [*c]u8; +pub extern fn get_user_command_name(idx: c_int, cmdidx: c_int) [*c]u8; +pub extern fn get_user_cmd_addr_type(xp: [*c]expand_T, idx: c_int) [*c]u8; +pub extern fn get_user_cmd_flags(xp: [*c]expand_T, idx: c_int) [*c]u8; +pub extern fn get_user_cmd_nargs(xp: [*c]expand_T, idx: c_int) [*c]u8; +pub extern fn get_user_cmd_complete(xp: [*c]expand_T, idx: c_int) [*c]u8; +pub extern fn cmdcomplete_str_to_type(complete_str: [*c]const u8) c_int; +pub extern fn parse_addr_type_arg(value: [*c]u8, vallen: c_int, addr_type_arg: [*c]cmd_addr_T) c_int; +pub extern fn parse_compl_arg(value: [*c]const u8, vallen: c_int, complp: [*c]c_int, argt: [*c]u32, compl_arg: [*c][*c]u8) c_int; +pub extern fn uc_validate_name(name: [*c]u8) [*c]u8; +pub extern fn uc_add_command(name: [*c]u8, name_len: usize, rep: [*c]const u8, argt: u32, def: i64, flags: c_int, context: c_int, compl_arg: [*c]u8, compl_luaref: LuaRef, preview_luaref: LuaRef, addr_type: cmd_addr_T, luaref: LuaRef, force: bool) c_int; +pub extern fn ex_command(eap: [*c]exarg_T) void; +pub extern fn ex_comclear(eap: [*c]exarg_T) void; +pub extern fn free_ucmd(cmd: [*c]ucmd_T) void; +pub extern fn uc_clear(gap: [*c]garray_T) void; +pub extern fn ex_delcommand(eap: [*c]exarg_T) void; +pub extern fn uc_split_args_iter(arg: [*c]const u8, arglen: usize, end: [*c]usize, buf: [*c]u8, len: [*c]usize) bool; +pub extern fn add_win_cmd_modifiers(buf: [*c]u8, cmod: [*c]const cmdmod_T, multi_mods: [*c]bool) usize; +pub extern fn uc_mods(buf: [*c]u8, cmod: [*c]const cmdmod_T, quote: bool) usize; +pub extern fn do_ucmd(eap: [*c]exarg_T, preview: bool) c_int; +pub extern fn commands_array(buf: [*c]buf_T) Dictionary; +pub extern fn nlua_add_api_functions(lstate: ?*lua_State) void; +pub const nlua_ref_state_t = extern struct { + nil_ref: LuaRef, + empty_dict_ref: LuaRef, + ref_count: c_int, +}; +pub extern fn nlua_get_nil_ref(lstate: ?*lua_State) LuaRef; +pub extern fn nlua_get_empty_dict_ref(lstate: ?*lua_State) LuaRef; +pub extern fn nlua_get_global_ref_count() c_int; +pub extern fn nlua_init(argv: [*c][*c]u8, argc: c_int, lua_arg0: c_int) void; +pub extern fn nlua_run_script(argv: [*c][*c]u8, argc: c_int, lua_arg0: c_int) noreturn; +pub extern fn nlua_init_state(thread: bool) ?*lua_State; +pub extern fn nlua_free_all_mem() void; +pub extern fn nlua_in_fast_event(lstate: ?*lua_State) c_int; +pub extern fn nlua_call(lstate: ?*lua_State) c_int; +pub extern fn nlua_ref(lstate: ?*lua_State, ref_state: [*c]nlua_ref_state_t, index: c_int) LuaRef; +pub extern fn nlua_ref_global(lstate: ?*lua_State, index: c_int) LuaRef; +pub extern fn nlua_unref(lstate: ?*lua_State, ref_state: [*c]nlua_ref_state_t, ref: LuaRef) void; +pub extern fn nlua_unref_global(lstate: ?*lua_State, ref: LuaRef) void; +pub extern fn api_free_luaref(ref: LuaRef) void; +pub extern fn nlua_pushref(lstate: ?*lua_State, ref: LuaRef) void; +pub extern fn api_new_luaref(original_ref: LuaRef) LuaRef; +pub extern fn nlua_typval_eval(str: String, arg: [*c]typval_T, ret_tv: [*c]typval_T) void; +pub extern fn nlua_typval_call(str: [*c]const u8, len: usize, args: [*c]typval_T, argcount: c_int, ret_tv: [*c]typval_T) void; +pub extern fn nlua_call_user_expand_func(xp: [*c]expand_T, ret_tv: [*c]typval_T) void; +pub extern fn nlua_source_using_linegetter(fgetline: LineGetter, cookie: ?*anyopaque, name: [*c]u8) c_int; +pub extern fn typval_exec_lua_callable(lua_cb: LuaRef, argcount: c_int, argvars: [*c]typval_T, rettv: [*c]typval_T) c_int; +pub extern fn nlua_exec(str: String, args: Array, err: [*c]Error) Object; +pub extern fn nlua_ref_is_function(ref: LuaRef) bool; +pub extern fn nlua_call_ref(ref: LuaRef, name: [*c]const u8, args: Array, retval: bool, err: [*c]Error) Object; +pub extern fn nlua_is_deferred_safe() bool; +pub extern fn ex_lua(eap: [*c]exarg_T) void; +pub extern fn ex_luado(eap: [*c]exarg_T) void; +pub extern fn ex_luafile(eap: [*c]exarg_T) void; +pub extern fn nlua_exec_file(path: [*c]const u8) bool; +pub extern fn tslua_get_language_version(L: ?*lua_State) c_int; +pub extern fn tslua_get_minimum_language_version(L: ?*lua_State) c_int; +pub extern fn nlua_expand_pat(xp: [*c]expand_T, pat: [*c]u8, num_results: [*c]c_int, results: [*c][*c][*c]u8) c_int; +pub extern fn nlua_is_table_from_lua(arg: [*c]const typval_T) bool; +pub extern fn nlua_register_table_as_callable(arg: [*c]const typval_T) [*c]u8; +pub extern fn nlua_execute_on_key(c: c_int) void; +pub extern fn nlua_set_sctx(current: [*c]sctx_T) void; +pub extern fn nlua_do_ucmd(cmd: [*c]ucmd_T, eap: [*c]exarg_T, preview: bool) c_int; +pub extern fn nlua_funcref_str(ref: LuaRef) [*c]u8; +pub extern fn nlua_read_secure(path: [*c]const u8) [*c]u8; +pub extern fn nlua_trust(action: [*c]const u8, path: [*c]const u8) bool; +pub extern var nlua_global_refs: [*c]nlua_ref_state_t; +pub extern var nlua_disable_preload: bool; +pub extern fn luaopen_base(L: ?*lua_State) c_int; +pub extern fn luaopen_coroutine(L: ?*lua_State) c_int; +pub extern fn luaopen_table(L: ?*lua_State) c_int; +pub extern fn luaopen_io(L: ?*lua_State) c_int; +pub extern fn luaopen_os(L: ?*lua_State) c_int; +pub extern fn luaopen_string(L: ?*lua_State) c_int; +pub extern fn luaopen_utf8(L: ?*lua_State) c_int; +pub extern fn luaopen_math(L: ?*lua_State) c_int; +pub extern fn luaopen_debug(L: ?*lua_State) c_int; +pub extern fn luaopen_package(L: ?*lua_State) c_int; +pub extern fn luaL_openlibs(L: ?*lua_State) void; +pub extern fn nlua_spell_check(lstate: ?*lua_State) c_int; +pub extern fn luaopen_spell(L: ?*lua_State) c_int; +pub extern fn nlua_str_utfindex(lstate: ?*lua_State) c_int; +pub extern fn nlua_str_byteindex(lstate: ?*lua_State) c_int; +pub extern fn nlua_regex(lstate: ?*lua_State) c_int; +pub extern fn nlua_setvar(lstate: ?*lua_State) c_int; +pub extern fn nlua_getvar(lstate: ?*lua_State) c_int; +pub extern fn nlua_state_add_stdlib(lstate: ?*lua_State, is_thread: bool) void; +pub extern fn nlua_push_errstr(L: ?*lua_State, fmt: [*c]const u8, ...) void; +pub const TSSymbol = u16; +pub const TSFieldId = u16; +pub const struct_TSLanguage = opaque {}; +pub const TSLanguage = struct_TSLanguage; +pub const struct_TSParser = opaque {}; +pub const TSParser = struct_TSParser; +pub const struct_TSTree = opaque {}; +pub const TSTree = struct_TSTree; +pub const struct_TSQuery = opaque {}; +pub const TSQuery = struct_TSQuery; +pub const struct_TSQueryCursor = opaque {}; +pub const TSQueryCursor = struct_TSQueryCursor; +pub const TSInputEncodingUTF8: c_int = 0; +pub const TSInputEncodingUTF16: c_int = 1; +pub const TSInputEncoding = c_uint; +pub const TSSymbolTypeRegular: c_int = 0; +pub const TSSymbolTypeAnonymous: c_int = 1; +pub const TSSymbolTypeAuxiliary: c_int = 2; +pub const TSSymbolType = c_uint; +pub const TSPoint = extern struct { + row: u32, + column: u32, +}; +pub const TSRange = extern struct { + start_point: TSPoint, + end_point: TSPoint, + start_byte: u32, + end_byte: u32, +}; +pub const TSInput = extern struct { + payload: ?*anyopaque, + read: ?*const fn (?*anyopaque, u32, TSPoint, [*c]u32) callconv(.C) [*c]const u8, + encoding: TSInputEncoding, +}; +pub const TSLogTypeParse: c_int = 0; +pub const TSLogTypeLex: c_int = 1; +pub const TSLogType = c_uint; +pub const TSLogger = extern struct { + payload: ?*anyopaque, + log: ?*const fn (?*anyopaque, TSLogType, [*c]const u8) callconv(.C) void, +}; +pub const TSInputEdit = extern struct { + start_byte: u32, + old_end_byte: u32, + new_end_byte: u32, + start_point: TSPoint, + old_end_point: TSPoint, + new_end_point: TSPoint, +}; +pub const TSNode = extern struct { + context: [4]u32, + id: ?*const anyopaque, + tree: ?*const TSTree, +}; +pub const TSTreeCursor = extern struct { + tree: ?*const anyopaque, + id: ?*const anyopaque, + context: [2]u32, +}; +pub const TSQueryCapture = extern struct { + node: TSNode, + index: u32, +}; +pub const TSQuantifierZero: c_int = 0; +pub const TSQuantifierZeroOrOne: c_int = 1; +pub const TSQuantifierZeroOrMore: c_int = 2; +pub const TSQuantifierOne: c_int = 3; +pub const TSQuantifierOneOrMore: c_int = 4; +pub const TSQuantifier = c_uint; +pub const TSQueryMatch = extern struct { + id: u32, + pattern_index: u16, + capture_count: u16, + captures: [*c]const TSQueryCapture, +}; +pub const TSQueryPredicateStepTypeDone: c_int = 0; +pub const TSQueryPredicateStepTypeCapture: c_int = 1; +pub const TSQueryPredicateStepTypeString: c_int = 2; +pub const TSQueryPredicateStepType = c_uint; +pub const TSQueryPredicateStep = extern struct { + type: TSQueryPredicateStepType, + value_id: u32, +}; +pub const TSQueryErrorNone: c_int = 0; +pub const TSQueryErrorSyntax: c_int = 1; +pub const TSQueryErrorNodeType: c_int = 2; +pub const TSQueryErrorField: c_int = 3; +pub const TSQueryErrorCapture: c_int = 4; +pub const TSQueryErrorStructure: c_int = 5; +pub const TSQueryErrorLanguage: c_int = 6; +pub const TSQueryError = c_uint; +pub extern fn ts_parser_new() ?*TSParser; +pub extern fn ts_parser_delete(parser: ?*TSParser) void; +pub extern fn ts_parser_set_language(self: ?*TSParser, language: ?*const TSLanguage) bool; +pub extern fn ts_parser_language(self: ?*const TSParser) ?*const TSLanguage; +pub extern fn ts_parser_set_included_ranges(self: ?*TSParser, ranges: [*c]const TSRange, length: u32) bool; +pub extern fn ts_parser_included_ranges(self: ?*const TSParser, length: [*c]u32) [*c]const TSRange; +pub extern fn ts_parser_parse(self: ?*TSParser, old_tree: ?*const TSTree, input: TSInput) ?*TSTree; +pub extern fn ts_parser_parse_string(self: ?*TSParser, old_tree: ?*const TSTree, string: [*c]const u8, length: u32) ?*TSTree; +pub extern fn ts_parser_parse_string_encoding(self: ?*TSParser, old_tree: ?*const TSTree, string: [*c]const u8, length: u32, encoding: TSInputEncoding) ?*TSTree; +pub extern fn ts_parser_reset(self: ?*TSParser) void; +pub extern fn ts_parser_set_timeout_micros(self: ?*TSParser, timeout: u64) void; +pub extern fn ts_parser_timeout_micros(self: ?*const TSParser) u64; +pub extern fn ts_parser_set_cancellation_flag(self: ?*TSParser, flag: [*c]const usize) void; +pub extern fn ts_parser_cancellation_flag(self: ?*const TSParser) [*c]const usize; +pub extern fn ts_parser_set_logger(self: ?*TSParser, logger: TSLogger) void; +pub extern fn ts_parser_logger(self: ?*const TSParser) TSLogger; +pub extern fn ts_parser_print_dot_graphs(self: ?*TSParser, file: c_int) void; +pub extern fn ts_tree_copy(self: ?*const TSTree) ?*TSTree; +pub extern fn ts_tree_delete(self: ?*TSTree) void; +pub extern fn ts_tree_root_node(self: ?*const TSTree) TSNode; +pub extern fn ts_tree_root_node_with_offset(self: ?*const TSTree, offset_bytes: u32, offset_point: TSPoint) TSNode; +pub extern fn ts_tree_language(?*const TSTree) ?*const TSLanguage; +pub extern fn ts_tree_included_ranges(?*const TSTree, length: [*c]u32) [*c]TSRange; +pub extern fn ts_tree_edit(self: ?*TSTree, edit: [*c]const TSInputEdit) void; +pub extern fn ts_tree_get_changed_ranges(old_tree: ?*const TSTree, new_tree: ?*const TSTree, length: [*c]u32) [*c]TSRange; +pub extern fn ts_tree_print_dot_graph(?*const TSTree, file_descriptor: c_int) void; +pub extern fn ts_node_type(TSNode) [*c]const u8; +pub extern fn ts_node_symbol(TSNode) TSSymbol; +pub extern fn ts_node_start_byte(TSNode) u32; +pub extern fn ts_node_start_point(TSNode) TSPoint; +pub extern fn ts_node_end_byte(TSNode) u32; +pub extern fn ts_node_end_point(TSNode) TSPoint; +pub extern fn ts_node_string(TSNode) [*c]u8; +pub extern fn ts_node_is_null(TSNode) bool; +pub extern fn ts_node_is_named(TSNode) bool; +pub extern fn ts_node_is_missing(TSNode) bool; +pub extern fn ts_node_is_extra(TSNode) bool; +pub extern fn ts_node_has_changes(TSNode) bool; +pub extern fn ts_node_has_error(TSNode) bool; +pub extern fn ts_node_parent(TSNode) TSNode; +pub extern fn ts_node_child(TSNode, u32) TSNode; +pub extern fn ts_node_field_name_for_child(TSNode, u32) [*c]const u8; +pub extern fn ts_node_child_count(TSNode) u32; +pub extern fn ts_node_named_child(TSNode, u32) TSNode; +pub extern fn ts_node_named_child_count(TSNode) u32; +pub extern fn ts_node_child_by_field_name(self: TSNode, field_name: [*c]const u8, field_name_length: u32) TSNode; +pub extern fn ts_node_child_by_field_id(TSNode, TSFieldId) TSNode; +pub extern fn ts_node_next_sibling(TSNode) TSNode; +pub extern fn ts_node_prev_sibling(TSNode) TSNode; +pub extern fn ts_node_next_named_sibling(TSNode) TSNode; +pub extern fn ts_node_prev_named_sibling(TSNode) TSNode; +pub extern fn ts_node_first_child_for_byte(TSNode, u32) TSNode; +pub extern fn ts_node_first_named_child_for_byte(TSNode, u32) TSNode; +pub extern fn ts_node_descendant_for_byte_range(TSNode, u32, u32) TSNode; +pub extern fn ts_node_descendant_for_point_range(TSNode, TSPoint, TSPoint) TSNode; +pub extern fn ts_node_named_descendant_for_byte_range(TSNode, u32, u32) TSNode; +pub extern fn ts_node_named_descendant_for_point_range(TSNode, TSPoint, TSPoint) TSNode; +pub extern fn ts_node_edit([*c]TSNode, [*c]const TSInputEdit) void; +pub extern fn ts_node_eq(TSNode, TSNode) bool; +pub extern fn ts_tree_cursor_new(TSNode) TSTreeCursor; +pub extern fn ts_tree_cursor_delete([*c]TSTreeCursor) void; +pub extern fn ts_tree_cursor_reset([*c]TSTreeCursor, TSNode) void; +pub extern fn ts_tree_cursor_current_node([*c]const TSTreeCursor) TSNode; +pub extern fn ts_tree_cursor_current_field_name([*c]const TSTreeCursor) [*c]const u8; +pub extern fn ts_tree_cursor_current_field_id([*c]const TSTreeCursor) TSFieldId; +pub extern fn ts_tree_cursor_goto_parent([*c]TSTreeCursor) bool; +pub extern fn ts_tree_cursor_goto_next_sibling([*c]TSTreeCursor) bool; +pub extern fn ts_tree_cursor_goto_first_child([*c]TSTreeCursor) bool; +pub extern fn ts_tree_cursor_goto_first_child_for_byte([*c]TSTreeCursor, u32) i64; +pub extern fn ts_tree_cursor_goto_first_child_for_point([*c]TSTreeCursor, TSPoint) i64; +pub extern fn ts_tree_cursor_copy([*c]const TSTreeCursor) TSTreeCursor; +pub extern fn ts_query_new(language: ?*const TSLanguage, source: [*c]const u8, source_len: u32, error_offset: [*c]u32, error_type: [*c]TSQueryError) ?*TSQuery; +pub extern fn ts_query_delete(?*TSQuery) void; +pub extern fn ts_query_pattern_count(?*const TSQuery) u32; +pub extern fn ts_query_capture_count(?*const TSQuery) u32; +pub extern fn ts_query_string_count(?*const TSQuery) u32; +pub extern fn ts_query_start_byte_for_pattern(?*const TSQuery, u32) u32; +pub extern fn ts_query_predicates_for_pattern(self: ?*const TSQuery, pattern_index: u32, length: [*c]u32) [*c]const TSQueryPredicateStep; +pub extern fn ts_query_is_pattern_rooted(self: ?*const TSQuery, pattern_index: u32) bool; +pub extern fn ts_query_is_pattern_non_local(self: ?*const TSQuery, pattern_index: u32) bool; +pub extern fn ts_query_is_pattern_guaranteed_at_step(self: ?*const TSQuery, byte_offset: u32) bool; +pub extern fn ts_query_capture_name_for_id(?*const TSQuery, id: u32, length: [*c]u32) [*c]const u8; +pub extern fn ts_query_capture_quantifier_for_id(?*const TSQuery, pattern_id: u32, capture_id: u32) TSQuantifier; +pub extern fn ts_query_string_value_for_id(?*const TSQuery, id: u32, length: [*c]u32) [*c]const u8; +pub extern fn ts_query_disable_capture(?*TSQuery, [*c]const u8, u32) void; +pub extern fn ts_query_disable_pattern(?*TSQuery, u32) void; +pub extern fn ts_query_cursor_new() ?*TSQueryCursor; +pub extern fn ts_query_cursor_delete(?*TSQueryCursor) void; +pub extern fn ts_query_cursor_exec(?*TSQueryCursor, ?*const TSQuery, TSNode) void; +pub extern fn ts_query_cursor_did_exceed_match_limit(?*const TSQueryCursor) bool; +pub extern fn ts_query_cursor_match_limit(?*const TSQueryCursor) u32; +pub extern fn ts_query_cursor_set_match_limit(?*TSQueryCursor, u32) void; +pub extern fn ts_query_cursor_set_byte_range(?*TSQueryCursor, u32, u32) void; +pub extern fn ts_query_cursor_set_point_range(?*TSQueryCursor, TSPoint, TSPoint) void; +pub extern fn ts_query_cursor_next_match(?*TSQueryCursor, match: [*c]TSQueryMatch) bool; +pub extern fn ts_query_cursor_remove_match(?*TSQueryCursor, id: u32) void; +pub extern fn ts_query_cursor_next_capture(?*TSQueryCursor, match: [*c]TSQueryMatch, capture_index: [*c]u32) bool; +pub extern fn ts_language_symbol_count(?*const TSLanguage) u32; +pub extern fn ts_language_symbol_name(?*const TSLanguage, TSSymbol) [*c]const u8; +pub extern fn ts_language_symbol_for_name(self: ?*const TSLanguage, string: [*c]const u8, length: u32, is_named: bool) TSSymbol; +pub extern fn ts_language_field_count(?*const TSLanguage) u32; +pub extern fn ts_language_field_name_for_id(?*const TSLanguage, TSFieldId) [*c]const u8; +pub extern fn ts_language_field_id_for_name(?*const TSLanguage, [*c]const u8, u32) TSFieldId; +pub extern fn ts_language_symbol_type(?*const TSLanguage, TSSymbol) TSSymbolType; +pub extern fn ts_language_version(?*const TSLanguage) u32; +pub extern fn ts_set_allocator(new_malloc: ?*const fn (usize) callconv(.C) ?*anyopaque, new_calloc: ?*const fn (usize, usize) callconv(.C) ?*anyopaque, new_realloc: ?*const fn (?*anyopaque, usize) callconv(.C) ?*anyopaque, new_free: ?*const fn (?*anyopaque) callconv(.C) void) void; +pub extern fn tslua_init(L: ?*lua_State) void; +pub extern fn tslua_has_language(L: ?*lua_State) c_int; +pub extern fn tslua_add_language(L: ?*lua_State) c_int; +pub extern fn tslua_remove_lang(L: ?*lua_State) c_int; +pub extern fn tslua_inspect_lang(L: ?*lua_State) c_int; +pub extern fn tslua_push_parser(L: ?*lua_State) c_int; +pub extern fn push_tree(L: ?*lua_State, tree: ?*TSTree, do_copy: bool) void; +pub extern fn tslua_parse_query(L: ?*lua_State) c_int; +pub extern fn nlua_xdl_diff(lstate: ?*lua_State) c_int; +pub const struct_map_arguments = extern struct { + buffer: bool, + expr: bool, + noremap: bool, + nowait: bool, + script: bool, + silent: bool, + unique: bool, + replace_keycodes: bool, + lhs: [51]u8, + lhs_len: usize, + alt_lhs: [51]u8, + alt_lhs_len: usize, + rhs: [*c]u8, + rhs_len: usize, + rhs_lua: LuaRef, + rhs_is_noop: bool, + orig_rhs: [*c]u8, + orig_rhs_len: usize, + desc: [*c]u8, +}; +pub const MapArguments = struct_map_arguments; +pub extern fn get_maphash_list(state: c_int, c: c_int) [*c]mapblock_T; +pub extern fn get_buf_maphash_list(state: c_int, c: c_int) [*c]mapblock_T; +pub extern fn get_maphash(index: c_int, buf: [*c]buf_T) [*c]mapblock_T; +pub extern fn do_map(maptype: c_int, arg: [*c]u8, mode: c_int, is_abbrev: bool) c_int; +pub extern fn map_clear_mode(buf: [*c]buf_T, mode: c_int, local: bool, abbr: bool) void; +pub extern fn map_to_exists(str: [*c]const u8, modechars: [*c]const u8, abbr: bool) bool; +pub extern fn map_to_exists_mode(rhs: [*c]const u8, mode: c_int, abbr: bool) c_int; +pub extern fn set_context_in_map_cmd(xp: [*c]expand_T, cmd: [*c]u8, arg: [*c]u8, forceit: bool, isabbrev: bool, isunmap: bool, cmdidx: cmdidx_T) [*c]u8; +pub extern fn ExpandMappings(pat: [*c]u8, regmatch: [*c]regmatch_T, numMatches: [*c]c_int, matches: [*c][*c][*c]u8) c_int; +pub extern fn check_abbr(c: c_int, ptr: [*c]u8, col: c_int, mincol: c_int) bool; +pub extern fn eval_map_expr(mp: [*c]mapblock_T, c: c_int) [*c]u8; +pub extern fn makemap(fd: [*c]FILE, buf: [*c]buf_T) c_int; +pub extern fn put_escstr(fd: [*c]FILE, strstart: [*c]u8, what: c_int) c_int; +pub extern fn check_map(keys: [*c]u8, mode: c_int, exact: c_int, ign_mod: c_int, abbr: c_int, mp_ptr: [*c][*c]mapblock_T, local_ptr: [*c]c_int, rhs_lua: [*c]c_int) [*c]u8; +pub extern fn f_hasmapto(argvars: [*c]typval_T, rettv: [*c]typval_T, fptr: EvalFuncData) void; +pub extern fn f_mapset(argvars: [*c]typval_T, rettv: [*c]typval_T, fptr: EvalFuncData) void; +pub extern fn f_maparg(argvars: [*c]typval_T, rettv: [*c]typval_T, fptr: EvalFuncData) void; +pub extern fn f_mapcheck(argvars: [*c]typval_T, rettv: [*c]typval_T, fptr: EvalFuncData) void; +pub extern fn add_map(lhs: [*c]u8, rhs: [*c]u8, mode: c_int, buffer: bool) void; +pub extern fn langmap_adjust_mb(c: c_int) c_int; +pub extern fn langmap_init() void; +pub extern fn langmap_set() void; +pub extern fn ex_abbreviate(eap: [*c]exarg_T) void; +pub extern fn ex_map(eap: [*c]exarg_T) void; +pub extern fn ex_unmap(eap: [*c]exarg_T) void; +pub extern fn ex_mapclear(eap: [*c]exarg_T) void; +pub extern fn ex_abclear(eap: [*c]exarg_T) void; +pub extern fn modify_keymap(channel_id: u64, buffer: Buffer, is_unmap: bool, mode: String, lhs: String, rhs: String, opts: [*c]KeyDict_keymap, err: [*c]Error) void; +pub extern fn keymap_array(mode: String, buf: [*c]buf_T) Array; +pub fn mark_global_index(name: u8) callconv(.C) c_int { + return if ((@bitCast(c_uint, @as(c_uint, name)) >= @bitCast(c_uint, @as(c_int, 'A'))) and (@bitCast(c_uint, @as(c_uint, name)) <= @bitCast(c_uint, @as(c_int, 'Z')))) @bitCast(c_int, @as(c_uint, name)) - @as(c_int, 'A') else if (@as(c_int, @boolToInt(ascii_isdigit(@bitCast(c_int, @as(c_uint, name))))) != 0) ((@as(c_int, 'z') - @as(c_int, 'a')) + @as(c_int, 1)) + (@bitCast(c_int, @as(c_uint, name)) - @as(c_int, '0')) else -@as(c_int, 1); +} +pub fn mark_local_index(name: u8) callconv(.C) c_int { + return if ((@bitCast(c_uint, @as(c_uint, name)) >= @bitCast(c_uint, @as(c_int, 'a'))) and (@bitCast(c_uint, @as(c_uint, name)) <= @bitCast(c_uint, @as(c_int, 'z')))) @bitCast(c_int, @as(c_uint, name)) - @as(c_int, 'a') else if (@bitCast(c_int, @as(c_uint, name)) == @as(c_int, '"')) (@as(c_int, 'z') - @as(c_int, 'a')) + @as(c_int, 1) else if (@bitCast(c_int, @as(c_uint, name)) == @as(c_int, '^')) ((@as(c_int, 'z') - @as(c_int, 'a')) + @as(c_int, 1)) + @as(c_int, 1) else if (@bitCast(c_int, @as(c_uint, name)) == @as(c_int, '.')) ((@as(c_int, 'z') - @as(c_int, 'a')) + @as(c_int, 1)) + @as(c_int, 2) else -@as(c_int, 1); +} +pub inline fn lt(arg_a: pos_T, arg_b: pos_T) bool { + var a = arg_a; + var b = arg_b; + if (a.lnum != b.lnum) { + return a.lnum < b.lnum; + } else if (a.col != b.col) { + return a.col < b.col; + } else { + return a.coladd < b.coladd; + } + return false; +} +pub inline fn equalpos(arg_a: pos_T, arg_b: pos_T) bool { + var a = arg_a; + var b = arg_b; + return ((a.lnum == b.lnum) and (a.col == b.col)) and (a.coladd == b.coladd); +} +pub inline fn ltoreq(arg_a: pos_T, arg_b: pos_T) bool { + var a = arg_a; + var b = arg_b; + return (@as(c_int, @boolToInt(lt(a, b))) != 0) or (@as(c_int, @boolToInt(equalpos(a, b))) != 0); +} +pub inline fn clearpos(arg_a: [*c]pos_T) void { + var a = arg_a; + a.*.lnum = 0; + a.*.col = 0; + a.*.coladd = 0; +} +pub extern fn setmark(c: c_int) c_int; +pub extern fn free_fmark(fm: fmark_T) void; +pub extern fn free_xfmark(fm: xfmark_T) void; +pub extern fn clear_fmark(fm: [*c]fmark_T) void; +pub extern fn setmark_pos(c: c_int, pos: [*c]pos_T, fnum: c_int, view_pt: [*c]fmarkv_T) c_int; +pub extern fn setpcmark() void; +pub extern fn checkpcmark() void; +pub extern fn get_jumplist(win: [*c]win_T, count: c_int) [*c]fmark_T; +pub extern fn get_changelist(buf: [*c]buf_T, win: [*c]win_T, count: c_int) [*c]fmark_T; +pub extern fn mark_get(buf: [*c]buf_T, win: [*c]win_T, fmp: [*c]fmark_T, flag: MarkGet, name: c_int) [*c]fmark_T; +pub extern fn mark_get_global(resolve: bool, name: c_int) [*c]xfmark_T; +pub extern fn mark_get_local(buf: [*c]buf_T, win: [*c]win_T, name: c_int) [*c]fmark_T; +pub extern fn mark_get_motion(buf: [*c]buf_T, win: [*c]win_T, name: c_int) [*c]fmark_T; +pub extern fn mark_get_visual(buf: [*c]buf_T, name: c_int) [*c]fmark_T; +pub extern fn pos_to_mark(buf: [*c]buf_T, fmp: [*c]fmark_T, pos: pos_T) [*c]fmark_T; +pub extern fn mark_move_to(fm: [*c]fmark_T, flags: MarkMove) MarkMoveRes; +pub extern fn mark_view_restore(fm: [*c]fmark_T) void; +pub extern fn mark_view_make(topline: linenr_T, pos: pos_T) fmarkv_T; +pub extern fn getnextmark(startpos: [*c]pos_T, dir: c_int, begin_line: c_int) [*c]fmark_T; +pub extern fn fmarks_check_names(buf: [*c]buf_T) void; +pub extern fn mark_check(fm: [*c]fmark_T) bool; +pub extern fn mark_check_line_bounds(buf: [*c]buf_T, fm: [*c]fmark_T) bool; +pub extern fn clrallmarks(buf: [*c]buf_T) void; +pub extern fn fm_getname(fmark: [*c]fmark_T, lead_len: c_int) [*c]u8; +pub extern fn ex_marks(eap: [*c]exarg_T) void; +pub extern fn ex_delmarks(eap: [*c]exarg_T) void; +pub extern fn ex_jumps(eap: [*c]exarg_T) void; +pub extern fn ex_clearjumps(eap: [*c]exarg_T) void; +pub extern fn ex_changes(eap: [*c]exarg_T) void; +pub extern fn mark_adjust(line1: linenr_T, line2: linenr_T, amount: linenr_T, amount_after: linenr_T, op: ExtmarkOp) void; +pub extern fn mark_adjust_nofold(line1: linenr_T, line2: linenr_T, amount: linenr_T, amount_after: linenr_T, op: ExtmarkOp) void; +pub extern fn mark_col_adjust(lnum: linenr_T, mincol: colnr_T, lnum_amount: linenr_T, col_amount: c_long, spaces_removed: c_int) void; +pub extern fn cleanup_jumplist(wp: [*c]win_T, loadfiles: bool) void; +pub extern fn copy_jumplist(from: [*c]win_T, to: [*c]win_T) void; +pub extern fn mark_jumplist_iter(iter: ?*const anyopaque, win: [*c]const win_T, fm: [*c]xfmark_T) ?*const anyopaque; +pub extern fn mark_global_iter(iter: ?*const anyopaque, name: [*c]u8, fm: [*c]xfmark_T) ?*const anyopaque; +pub extern fn mark_buffer_iter(iter: ?*const anyopaque, buf: [*c]const buf_T, name: [*c]u8, fm: [*c]fmark_T) ?*const anyopaque; +pub extern fn mark_set_global(name: u8, fm: xfmark_T, update: bool) bool; +pub extern fn mark_set_local(name: u8, buf: [*c]buf_T, fm: fmark_T, update: bool) bool; +pub extern fn free_jumplist(wp: [*c]win_T) void; +pub extern fn set_last_cursor(win: [*c]win_T) void; +pub extern fn mark_mb_adjustpos(buf: [*c]buf_T, lp: [*c]pos_T) void; +pub extern fn get_buf_local_marks(buf: [*c]const buf_T, l: [*c]list_T) void; +pub extern fn get_raw_global_mark(name: u8) xfmark_T; +pub extern fn get_global_marks(l: [*c]list_T) void; +pub extern fn clear_matches(wp: [*c]win_T) void; +pub extern fn init_search_hl(wp: [*c]win_T, search_hl: [*c]match_T) void; +pub extern fn prepare_search_hl(wp: [*c]win_T, search_hl: [*c]match_T, lnum: linenr_T) void; +pub extern fn prepare_search_hl_line(wp: [*c]win_T, lnum: linenr_T, mincol: colnr_T, line: [*c][*c]u8, search_hl: [*c]match_T, search_attr: [*c]c_int, search_attr_from_match: [*c]bool) bool; +pub extern fn update_search_hl(wp: [*c]win_T, lnum: linenr_T, col: colnr_T, line: [*c][*c]u8, search_hl: [*c]match_T, has_match_conc: [*c]c_int, match_conc: [*c]c_int, lcs_eol_one: c_int, on_last_col: [*c]bool, search_attr_from_match: [*c]bool) c_int; +pub extern fn get_prevcol_hl_flag(wp: [*c]win_T, search_hl: [*c]match_T, curcol: c_long) bool; +pub extern fn get_search_match_hl(wp: [*c]win_T, search_hl: [*c]match_T, col: c_long, char_attr: [*c]c_int) void; +pub extern fn f_clearmatches(argvars: [*c]typval_T, rettv: [*c]typval_T, fptr: EvalFuncData) void; +pub extern fn f_getmatches(argvars: [*c]typval_T, rettv: [*c]typval_T, fptr: EvalFuncData) void; +pub extern fn f_setmatches(argvars: [*c]typval_T, rettv: [*c]typval_T, fptr: EvalFuncData) void; +pub extern fn f_matchadd(argvars: [*c]typval_T, rettv: [*c]typval_T, fptr: EvalFuncData) void; +pub extern fn f_matchaddpos(argvars: [*c]typval_T, rettv: [*c]typval_T, fptr: EvalFuncData) void; +pub extern fn f_matcharg(argvars: [*c]typval_T, rettv: [*c]typval_T, fptr: EvalFuncData) void; +pub extern fn f_matchdelete(argvars: [*c]typval_T, rettv: [*c]typval_T, fptr: EvalFuncData) void; +pub extern fn ex_match(eap: [*c]exarg_T) void; +pub extern fn xfpclassify(d: f64) c_int; +pub extern fn xisinf(d: f64) c_int; +pub extern fn xisnan(d: f64) c_int; +pub extern fn mf_open(fname: [*c]u8, flags: c_int) [*c]memfile_T; +pub extern fn mf_open_file(mfp: [*c]memfile_T, fname: [*c]u8) c_int; +pub extern fn mf_close(mfp: [*c]memfile_T, del_file: bool) void; +pub extern fn mf_close_file(buf: [*c]buf_T, getlines: bool) void; +pub extern fn mf_new_page_size(mfp: [*c]memfile_T, new_size: c_uint) void; +pub extern fn mf_new(mfp: [*c]memfile_T, negative: bool, page_count: c_uint) [*c]bhdr_T; +pub extern fn mf_get(mfp: [*c]memfile_T, nr: blocknr_T, page_count: c_uint) [*c]bhdr_T; +pub extern fn mf_put(mfp: [*c]memfile_T, hp: [*c]bhdr_T, dirty: bool, infile: bool) void; +pub extern fn mf_free(mfp: [*c]memfile_T, hp: [*c]bhdr_T) void; +pub extern fn mf_sync(mfp: [*c]memfile_T, flags: c_int) c_int; +pub extern fn mf_set_dirty(mfp: [*c]memfile_T) void; +pub extern fn mf_release_all() bool; +pub extern fn mf_trans_del(mfp: [*c]memfile_T, old_nr: blocknr_T) blocknr_T; +pub extern fn mf_free_fnames(mfp: [*c]memfile_T) void; +pub extern fn mf_set_fnames(mfp: [*c]memfile_T, fname: [*c]u8) void; +pub extern fn mf_fullname(mfp: [*c]memfile_T) void; +pub extern fn mf_need_trans(mfp: [*c]memfile_T) bool; +pub extern fn ex_menu(eap: [*c]exarg_T) void; +pub extern fn menu_get(path_name: [*c]u8, modes: c_int, list: [*c]list_T) bool; +pub extern fn set_context_in_menu_cmd(xp: [*c]expand_T, cmd: [*c]const u8, arg: [*c]u8, forceit: bool) [*c]u8; +pub extern fn get_menu_name(xp: [*c]expand_T, idx: c_int) [*c]u8; +pub extern fn get_menu_names(xp: [*c]expand_T, idx: c_int) [*c]u8; +pub extern fn menu_name_skip(name: [*c]u8) [*c]u8; +pub extern fn get_menu_cmd_modes(cmd: [*c]const u8, forceit: bool, noremap: [*c]c_int, unmenu: [*c]c_int) c_int; +pub extern fn menu_is_menubar(name: [*c]const u8) bool; +pub extern fn menu_is_popup(name: [*c]const u8) bool; +pub extern fn menu_is_toolbar(name: [*c]const u8) bool; +pub extern fn menu_is_separator(name: [*c]u8) c_int; +pub extern fn get_menu_mode_flag() c_int; +pub extern fn show_popupmenu() void; +pub extern fn execute_menu(eap: [*c]const exarg_T, menu: [*c]vimmenu_T, mode_idx: c_int) void; +pub extern fn ex_emenu(eap: [*c]exarg_T) void; +pub extern fn menu_find(path_name: [*c]const u8) [*c]vimmenu_T; +pub extern fn ex_menutranslate(eap: [*c]exarg_T) void; +pub extern fn f_menu_info(argvars: [*c]typval_T, rettv: [*c]typval_T, fptr: EvalFuncData) void; +pub extern var p_ch_was_zero: bool; +pub extern fn prevwin_curwin() [*c]win_T; +pub extern fn do_window(nchar: c_int, Prenum: c_long, xchar: c_int) void; +pub extern fn win_set_buf(window: Window, buffer: Buffer, noautocmd: bool, err: [*c]Error) void; +pub extern fn win_new_float(wp: [*c]win_T, last: bool, fconfig: FloatConfig, err: [*c]Error) [*c]win_T; +pub extern fn win_set_minimal_style(wp: [*c]win_T) void; +pub extern fn win_config_float(wp: [*c]win_T, fconfig: FloatConfig) void; +pub extern fn win_check_anchored_floats(win: [*c]win_T) void; +pub extern fn win_fdccol_count(wp: [*c]win_T) c_int; +pub extern fn ui_ext_win_position(wp: [*c]win_T, validate: bool) void; +pub extern fn ui_ext_win_viewport(wp: [*c]win_T) void; +pub extern fn win_split(size: c_int, flags: c_int) c_int; +pub extern fn win_split_ins(size: c_int, flags: c_int, new_wp: [*c]win_T, dir: c_int) c_int; +pub extern fn win_valid_floating(win: [*c]const win_T) bool; +pub extern fn win_valid(win: [*c]const win_T) bool; +pub extern fn win_find_by_handle(handle: handle_T) [*c]win_T; +pub extern fn win_valid_any_tab(win: [*c]win_T) bool; +pub extern fn win_count() c_int; +pub extern fn make_windows(count: c_int, vertical: bool) c_int; +pub extern fn win_move_after(win1: [*c]win_T, win2: [*c]win_T) void; +pub extern fn win_equal(next_curwin: [*c]win_T, current: bool, dir: c_int) void; +pub extern fn leaving_window(win: [*c]win_T) void; +pub extern fn entering_window(win: [*c]win_T) void; +pub extern fn win_init_empty(wp: [*c]win_T) void; +pub extern fn curwin_init() void; +pub extern fn close_windows(buf: [*c]buf_T, keep_curwin: bool) void; +pub extern fn last_window(win: [*c]win_T) bool; +pub extern fn one_window(win: [*c]win_T) bool; +pub extern fn one_nonfloat() bool; +pub extern fn last_nonfloat(wp: [*c]win_T) bool; +pub extern fn win_close(win: [*c]win_T, free_buf: bool, force: bool) c_int; +pub extern fn win_close_othertab(win: [*c]win_T, free_buf: c_int, tp: [*c]tabpage_T) void; +pub extern fn winframe_remove(win: [*c]win_T, dirp: [*c]c_int, tp: [*c]tabpage_T) [*c]win_T; +pub extern fn frame2win(frp: [*c]frame_T) [*c]win_T; +pub extern fn frame_new_height(topfrp: [*c]frame_T, height: c_int, topfirst: bool, wfh: bool) void; +pub extern fn close_others(message: c_int, forceit: c_int) void; +pub extern fn unuse_tabpage(tp: [*c]tabpage_T) void; +pub extern fn use_tabpage(tp: [*c]tabpage_T) void; +pub extern fn win_alloc_first() void; +pub extern fn win_alloc_aucmd_win(idx: c_int) void; +pub extern fn win_init_size() void; +pub extern fn free_tabpage(tp: [*c]tabpage_T) void; +pub extern fn win_new_tabpage(after: c_int, filename: [*c]u8) c_int; +pub extern fn may_open_tabpage() c_int; +pub extern fn make_tabpages(maxcount: c_int) c_int; +pub extern fn valid_tabpage(tpc: [*c]tabpage_T) bool; +pub extern fn valid_tabpage_win(tpc: [*c]tabpage_T) c_int; +pub extern fn close_tabpage(tab: [*c]tabpage_T) void; +pub extern fn find_tabpage(n: c_int) [*c]tabpage_T; +pub extern fn tabpage_index(ftp: [*c]tabpage_T) c_int; +pub extern fn goto_tabpage(n: c_int) void; +pub extern fn goto_tabpage_tp(tp: [*c]tabpage_T, trigger_enter_autocmds: bool, trigger_leave_autocmds: bool) void; +pub extern fn goto_tabpage_lastused() bool; +pub extern fn goto_tabpage_win(tp: [*c]tabpage_T, wp: [*c]win_T) void; +pub extern fn tabpage_move(nr: c_int) void; +pub extern fn win_goto(wp: [*c]win_T) void; +pub extern fn win_find_tabpage(win: [*c]win_T) [*c]tabpage_T; +pub extern fn win_vert_neighbor(tp: [*c]tabpage_T, wp: [*c]win_T, up: bool, count: c_long) [*c]win_T; +pub extern fn win_horz_neighbor(tp: [*c]tabpage_T, wp: [*c]win_T, left: bool, count: c_long) [*c]win_T; +pub extern fn win_enter(wp: [*c]win_T, undo_sync: bool) void; +pub extern fn fix_current_dir() void; +pub extern fn buf_jump_open_win(buf: [*c]buf_T) [*c]win_T; +pub extern fn buf_jump_open_tab(buf: [*c]buf_T) [*c]win_T; +pub extern fn free_wininfo(wip: [*c]wininfo_T, bp: [*c]buf_T) void; +pub extern fn win_free_grid(wp: [*c]win_T, reinit: bool) void; +pub extern fn win_append(after: [*c]win_T, wp: [*c]win_T) void; +pub extern fn win_remove(wp: [*c]win_T, tp: [*c]tabpage_T) void; +pub extern fn win_new_screensize() void; +pub extern fn win_new_screen_rows() void; +pub extern fn win_new_screen_cols() void; +pub extern fn snapshot_windows_scroll_size() void; +pub extern fn may_make_initial_scroll_size_snapshot() void; +pub extern fn may_trigger_win_scrolled_resized() void; +pub extern fn win_size_save(gap: [*c]garray_T) void; +pub extern fn win_size_restore(gap: [*c]garray_T) void; +pub extern fn win_comp_pos() c_int; +pub extern fn win_reconfig_floats() void; +pub extern fn win_setheight(height: c_int) void; +pub extern fn win_setheight_win(height: c_int, win: [*c]win_T) void; +pub extern fn win_setwidth(width: c_int) void; +pub extern fn win_setwidth_win(width: c_int, wp: [*c]win_T) void; +pub extern fn did_set_winminheight() void; +pub extern fn did_set_winminwidth() void; +pub extern fn win_drag_status_line(dragwin: [*c]win_T, offset: c_int) void; +pub extern fn win_drag_vsep_line(dragwin: [*c]win_T, offset: c_int) void; +pub extern fn set_fraction(wp: [*c]win_T) void; +pub extern fn win_fix_scroll(resize: c_int) void; +pub extern fn win_new_height(wp: [*c]win_T, height: c_int) void; +pub extern fn scroll_to_fraction(wp: [*c]win_T, prev_height: c_int) void; +pub extern fn win_set_inner_size(wp: [*c]win_T, valid_cursor: bool) void; +pub extern fn win_new_width(wp: [*c]win_T, width: c_int) void; +pub extern fn win_comp_scroll(wp: [*c]win_T) void; +pub extern fn command_height() void; +pub extern fn grab_file_name(count: c_long, file_lnum: [*c]linenr_T) [*c]u8; +pub extern fn file_name_at_cursor(options: c_int, count: c_long, file_lnum: [*c]linenr_T) [*c]u8; +pub extern fn file_name_in_line(line: [*c]u8, col: c_int, options: c_int, count: c_long, rel_fname: [*c]u8, file_lnum: [*c]linenr_T) [*c]u8; +pub extern fn last_status(morewin: bool) void; +pub extern fn set_winbar_win(wp: [*c]win_T, make_room: bool, valid_cursor: bool) c_int; +pub extern fn set_winbar(make_room: bool) void; +pub extern fn tabline_height() c_int; +pub extern fn global_winbar_height() c_int; +pub extern fn global_stl_height() c_int; +pub extern fn min_rows() c_int; +pub extern fn only_one_window() bool; +pub extern fn check_lnums(do_curwin: bool) void; +pub extern fn check_lnums_nested(do_curwin: bool) void; +pub extern fn reset_lnums() void; +pub extern fn make_snapshot(idx: c_int) void; +pub extern fn restore_snapshot(idx: c_int, close_curwin: c_int) void; +pub extern fn check_colorcolumn(wp: [*c]win_T) [*c]const u8; +pub extern fn win_get_tabwin(id: handle_T, tabnr: [*c]c_int, winnr: [*c]c_int) void; +pub extern fn win_ui_flush(validate: bool) void; +pub extern fn lastwin_nofloating() [*c]win_T; +pub const IN_UNKNOWN: c_int = 0; +pub const IN_BUFFER: c_int = 1; +pub const IN_STATUS_LINE: c_int = 2; +pub const IN_SEP_LINE: c_int = 4; +pub const IN_OTHER_WIN: c_int = 8; +pub const CURSOR_MOVED: c_int = 256; +pub const MOUSE_FOLD_CLOSE: c_int = 512; +pub const MOUSE_FOLD_OPEN: c_int = 1024; +pub const MOUSE_WINBAR: c_int = 2048; +pub const MOUSE_STATUSCOL: c_int = 4096; +const enum_unnamed_146 = c_uint; +pub const MOUSE_FOCUS: c_int = 1; +pub const MOUSE_MAY_VIS: c_int = 2; +pub const MOUSE_DID_MOVE: c_int = 4; +pub const MOUSE_SETPOS: c_int = 8; +pub const MOUSE_MAY_STOP_VIS: c_int = 16; +pub const MOUSE_RELEASED: c_int = 32; +const enum_unnamed_147 = c_uint; +pub const MOUSE_LEFT: c_int = 0; +pub const MOUSE_MIDDLE: c_int = 1; +pub const MOUSE_RIGHT: c_int = 2; +pub const MOUSE_RELEASE: c_int = 3; +pub const MOUSE_X1: c_int = 768; +pub const MOUSE_X2: c_int = 1024; +const enum_unnamed_148 = c_uint; +pub const MSCR_DOWN: c_int = 0; +pub const MSCR_UP: c_int = 1; +pub const MSCR_LEFT: c_int = -1; +pub const MSCR_RIGHT: c_int = -2; +const enum_unnamed_149 = c_int; +pub extern fn do_mouse(oap: [*c]oparg_T, c: c_int, dir: c_int, count: c_long, fixindent: bool) bool; +pub extern fn is_mouse_key(c: c_int) bool; +pub extern fn reset_dragwin() void; +pub extern fn jump_to_mouse(flags: c_int, inclusive: [*c]bool, which_button: c_int) c_int; +pub extern fn mouse_comp_pos(win: [*c]win_T, rowp: [*c]c_int, colp: [*c]c_int, lnump: [*c]linenr_T) bool; +pub extern fn mouse_find_win(gridp: [*c]c_int, rowp: [*c]c_int, colp: [*c]c_int) [*c]win_T; +pub extern fn vcol2col(wp: [*c]win_T, lnum: linenr_T, vcol: colnr_T) colnr_T; +pub extern fn setmouse() void; +pub extern fn mouse_scroll_horiz(dir: c_int) bool; +pub extern fn mouse_check_fold() c_int; +pub extern fn update_topline(wp: [*c]win_T) void; +pub extern fn update_curswant_force() void; +pub extern fn update_curswant() void; +pub extern fn check_cursor_moved(wp: [*c]win_T) void; +pub extern fn changed_window_setting() void; +pub extern fn changed_window_setting_win(wp: [*c]win_T) void; +pub extern fn set_topline(wp: [*c]win_T, lnum: linenr_T) void; +pub extern fn changed_cline_bef_curs() void; +pub extern fn changed_cline_bef_curs_win(wp: [*c]win_T) void; +pub extern fn changed_line_abv_curs() void; +pub extern fn changed_line_abv_curs_win(wp: [*c]win_T) void; +pub extern fn changed_line_display_buf(buf: [*c]buf_T) void; +pub extern fn validate_botline(wp: [*c]win_T) void; +pub extern fn invalidate_botline() void; +pub extern fn invalidate_botline_win(wp: [*c]win_T) void; +pub extern fn approximate_botline_win(wp: [*c]win_T) void; +pub extern fn cursor_valid() c_int; +pub extern fn validate_cursor() void; +pub extern fn validate_virtcol() void; +pub extern fn validate_virtcol_win(wp: [*c]win_T) void; +pub extern fn validate_cheight() void; +pub extern fn validate_cursor_col() void; +pub extern fn win_col_off(wp: [*c]win_T) c_int; +pub extern fn curwin_col_off() c_int; +pub extern fn win_col_off2(wp: [*c]win_T) c_int; +pub extern fn curwin_col_off2() c_int; +pub extern fn curs_columns(wp: [*c]win_T, may_scroll: c_int) void; +pub extern fn textpos2screenpos(wp: [*c]win_T, pos: [*c]pos_T, rowp: [*c]c_int, scolp: [*c]c_int, ccolp: [*c]c_int, ecolp: [*c]c_int, local: bool) void; +pub extern fn f_screenpos(argvars: [*c]typval_T, rettv: [*c]typval_T, fptr: EvalFuncData) void; +pub extern fn f_virtcol2col(argvars: [*c]typval_T, rettv: [*c]typval_T, fptr: EvalFuncData) void; +pub extern fn scrolldown(line_count: c_long, byfold: c_int) bool; +pub extern fn scrollup(line_count: c_long, byfold: c_int) bool; +pub extern fn check_topfill(wp: [*c]win_T, down: bool) void; +pub extern fn scrolldown_clamp() void; +pub extern fn scrollup_clamp() void; +pub extern fn scroll_cursor_top(min_scroll: c_int, always: c_int) void; +pub extern fn set_empty_rows(wp: [*c]win_T, used: c_int) void; +pub extern fn scroll_cursor_bot(min_scroll: c_int, set_topbot: c_int) void; +pub extern fn scroll_cursor_halfway(atend: bool, prefer_above: bool) void; +pub extern fn cursor_correct() void; +pub extern fn onepage(dir: Direction, count: c_long) c_int; +pub extern fn halfpage(flag: bool, Prenum: linenr_T) void; +pub extern fn do_check_cursorbind() void; +pub extern var ch_before_blocking_events: ?*MultiQueue; +pub extern fn rpc_init() void; +pub extern fn rpc_start(channel: [*c]Channel) void; +pub extern fn rpc_send_event(id: u64, name: [*c]const u8, args: Array) bool; +pub extern fn rpc_send_call(id: u64, method_name: [*c]const u8, args: Array, result_mem: [*c]ArenaMem, err: [*c]Error) Object; +pub extern fn rpc_subscribe(id: u64, event: [*c]u8) void; +pub extern fn rpc_unsubscribe(id: u64, event: [*c]u8) void; +pub extern fn rpc_write_raw(id: u64, buffer: [*c]WBuffer) bool; +pub extern fn rpc_close(channel: [*c]Channel) void; +pub extern fn rpc_free(channel: [*c]Channel) void; +pub extern fn rpc_set_client_info(id: u64, info: Dictionary) void; +pub extern fn rpc_client_info(chan: [*c]Channel) Dictionary; +pub extern fn rpc_client_name(chan: [*c]Channel) [*c]const u8; +pub extern fn msgpack_rpc_helpers_init() void; +pub extern fn msgpack_rpc_to_object(obj: [*c]const msgpack_object, arg: [*c]Object) bool; +pub extern fn msgpack_rpc_to_array(obj: [*c]const msgpack_object, arg: [*c]Array) bool; +pub extern fn msgpack_rpc_to_dictionary(obj: [*c]const msgpack_object, arg: [*c]Dictionary) bool; +pub extern fn msgpack_rpc_from_boolean(result: Boolean, res: [*c]msgpack_packer) void; +pub extern fn msgpack_rpc_from_integer(result: Integer, res: [*c]msgpack_packer) void; +pub extern fn msgpack_rpc_from_float(result: Float, res: [*c]msgpack_packer) void; +pub extern fn msgpack_rpc_from_string(result: String, res: [*c]msgpack_packer) void; +pub extern fn msgpack_rpc_from_object(result: Object, res: [*c]msgpack_packer) void; +pub extern fn msgpack_rpc_from_array(result: Array, res: [*c]msgpack_packer) void; +pub extern fn msgpack_rpc_from_dictionary(result: Dictionary, res: [*c]msgpack_packer) void; +pub extern fn msgpack_rpc_serialize_request(request_id: u32, method: String, args: Array, pac: [*c]msgpack_packer) void; +pub extern fn msgpack_rpc_serialize_response(response_id: u32, err: [*c]Error, arg: Object, pac: [*c]msgpack_packer) void; +pub extern fn msgpack_rpc_method(req: [*c]msgpack_object) [*c]msgpack_object; +pub extern fn msgpack_rpc_args(req: [*c]msgpack_object) [*c]msgpack_object; +pub extern fn msgpack_rpc_validate(response_id: [*c]u32, req: [*c]msgpack_object, err: [*c]Error) MessageType; +pub extern fn server_init(listen_addr: [*c]const u8) bool; +pub extern fn server_teardown() void; +pub extern fn server_address_new(name: [*c]const u8) [*c]u8; +pub extern fn server_owns_pipe_address(path: [*c]const u8) bool; +pub extern fn server_start(addr: [*c]const u8) c_int; +pub extern fn server_stop(endpoint: [*c]u8) bool; +pub extern fn server_address_list(size: [*c]usize) [*c][*c]u8; +pub const mpack_sint32_t = c_int; +pub const MPACK_OK: c_int = 0; +pub const MPACK_EOF: c_int = 1; +pub const MPACK_ERROR: c_int = 2; +const enum_unnamed_150 = c_uint; +pub const MPACK_TOKEN_NIL: c_int = 1; +pub const MPACK_TOKEN_BOOLEAN: c_int = 2; +pub const MPACK_TOKEN_UINT: c_int = 3; +pub const MPACK_TOKEN_SINT: c_int = 4; +pub const MPACK_TOKEN_FLOAT: c_int = 5; +pub const MPACK_TOKEN_CHUNK: c_int = 6; +pub const MPACK_TOKEN_ARRAY: c_int = 7; +pub const MPACK_TOKEN_MAP: c_int = 8; +pub const MPACK_TOKEN_BIN: c_int = 9; +pub const MPACK_TOKEN_STR: c_int = 10; +pub const MPACK_TOKEN_EXT: c_int = 11; +pub const mpack_token_type_t = c_uint; +pub extern fn mpack_tokbuf_init(tb: [*c]mpack_tokbuf_t) void; +pub extern fn mpack_read(tb: [*c]mpack_tokbuf_t, b: [*c][*c]const u8, bl: [*c]usize, tok: [*c]mpack_token_t) c_int; +pub extern fn mpack_write(tb: [*c]mpack_tokbuf_t, b: [*c][*c]u8, bl: [*c]usize, tok: [*c]const mpack_token_t) c_int; +pub extern fn mpack_rtoken(buf: [*c][*c]const u8, buflen: [*c]usize, tok: [*c]mpack_token_t) c_int; +pub const mpack_sintmax_t = c_longlong; +pub const mpack_uintmax_t = c_ulonglong; +pub extern fn mpack_pack_nil() mpack_token_t; +pub extern fn mpack_pack_boolean(v: c_uint) mpack_token_t; +pub extern fn mpack_pack_uint(v: mpack_uintmax_t) mpack_token_t; +pub extern fn mpack_pack_sint(v: mpack_sintmax_t) mpack_token_t; +pub extern fn mpack_pack_float_compat(v: f64) mpack_token_t; +pub extern fn mpack_pack_float_fast(v: f64) mpack_token_t; +pub extern fn mpack_pack_number(v: f64) mpack_token_t; +pub extern fn mpack_pack_chunk(p: [*c]const u8, l: mpack_uint32_t) mpack_token_t; +pub extern fn mpack_pack_str(l: mpack_uint32_t) mpack_token_t; +pub extern fn mpack_pack_bin(l: mpack_uint32_t) mpack_token_t; +pub extern fn mpack_pack_ext(@"type": c_int, l: mpack_uint32_t) mpack_token_t; +pub extern fn mpack_pack_array(l: mpack_uint32_t) mpack_token_t; +pub extern fn mpack_pack_map(l: mpack_uint32_t) mpack_token_t; +pub extern fn mpack_unpack_boolean(t: mpack_token_t) bool; +pub extern fn mpack_unpack_uint(t: mpack_token_t) mpack_uintmax_t; +pub extern fn mpack_unpack_sint(t: mpack_token_t) mpack_sintmax_t; +pub extern fn mpack_unpack_float_fast(t: mpack_token_t) f64; +pub extern fn mpack_unpack_float_compat(t: mpack_token_t) f64; +pub extern fn mpack_unpack_number(t: mpack_token_t) f64; +pub const MPACK_EXCEPTION: c_int = -1; +pub const MPACK_NOMEM: c_int = 3; +const enum_unnamed_151 = c_int; +pub const mpack_data_t = extern union { + p: ?*anyopaque, + u: mpack_uintmax_t, + i: mpack_sintmax_t, + d: f64, +}; +pub const struct_mpack_node_s = extern struct { + tok: mpack_token_t, + pos: usize, + key_visited: c_int, + data: [2]mpack_data_t, +}; +pub const mpack_node_t = struct_mpack_node_s; +pub const mpack_one_parser_t = extern struct { + data: mpack_data_t, + size: mpack_uint32_t, + capacity: mpack_uint32_t, + status: c_int, + exiting: c_int, + tokbuf: mpack_tokbuf_t, + items: [1]mpack_node_t, +}; +pub const mpack_parser_t = extern struct { + data: mpack_data_t, + size: mpack_uint32_t, + capacity: mpack_uint32_t, + status: c_int, + exiting: c_int, + tokbuf: mpack_tokbuf_t, + items: [33]mpack_node_t, +}; +pub const mpack_walk_cb = ?*const fn ([*c]mpack_parser_t, [*c]mpack_node_t) callconv(.C) void; +pub extern fn mpack_parser_init(p: [*c]mpack_parser_t, c: mpack_uint32_t) void; +pub extern fn mpack_parse_tok(walker: [*c]mpack_parser_t, tok: mpack_token_t, enter_cb: mpack_walk_cb, exit_cb: mpack_walk_cb) c_int; +pub extern fn mpack_unparse_tok(walker: [*c]mpack_parser_t, tok: [*c]mpack_token_t, enter_cb: mpack_walk_cb, exit_cb: mpack_walk_cb) c_int; +pub extern fn mpack_parse(parser: [*c]mpack_parser_t, b: [*c][*c]const u8, bl: [*c]usize, enter_cb: mpack_walk_cb, exit_cb: mpack_walk_cb) c_int; +pub extern fn mpack_unparse(parser: [*c]mpack_parser_t, b: [*c][*c]u8, bl: [*c]usize, enter_cb: mpack_walk_cb, exit_cb: mpack_walk_cb) c_int; +pub extern fn mpack_parser_copy(d: [*c]mpack_parser_t, s: [*c]mpack_parser_t) void; +pub extern fn unpack(data: [*c]const u8, size: usize, err: [*c]Error) Object; +pub extern fn unpacker_init(p: [*c]Unpacker) void; +pub extern fn unpacker_teardown(p: [*c]Unpacker) void; +pub extern fn unpacker_parse_header(p: [*c]Unpacker) bool; +pub extern fn unpacker_advance(p: [*c]Unpacker) bool; +pub extern fn unpacker_parse_redraw(p: [*c]Unpacker) bool; +pub const Indenter = ?*const fn () callconv(.C) c_int; +pub const kGRegNoExpr: c_int = 1; +pub const kGRegExprSrc: c_int = 2; +pub const kGRegList: c_int = 4; +pub const enum_GRegFlags = c_uint; +pub const struct_yankreg = extern struct { + y_array: [*c][*c]u8, + y_size: usize, + y_type: MotionType, + y_width: colnr_T, + timestamp: Timestamp, + additional_data: [*c]dict_T, +}; +pub const yankreg_T = struct_yankreg; +pub const YREG_PASTE: c_int = 0; +pub const YREG_YANK: c_int = 1; +pub const YREG_PUT: c_int = 2; +pub const yreg_mode_t = c_uint; +pub fn op_reg_index(regname: c_int) callconv(.C) c_int { + if (ascii_isdigit(regname)) { + return regname - @as(c_int, '0'); + } else if ((@bitCast(c_uint, regname) >= @bitCast(c_uint, @as(c_int, 'a'))) and (@bitCast(c_uint, regname) <= @bitCast(c_uint, @as(c_int, 'z')))) { + return (@bitCast(c_int, @as(c_uint, @bitCast(u8, @truncate(i8, regname)))) - @as(c_int, 'a')) + @as(c_int, 10); + } else if ((@bitCast(c_uint, regname) >= @bitCast(c_uint, @as(c_int, 'A'))) and (@bitCast(c_uint, regname) <= @bitCast(c_uint, @as(c_int, 'Z')))) { + return (@bitCast(c_int, @as(c_uint, @bitCast(u8, @truncate(i8, regname)))) - @as(c_int, 'A')) + @as(c_int, 10); + } else if (regname == @as(c_int, '-')) { + return 36; + } else if (regname == @as(c_int, '*')) { + return 37; + } else if (regname == @as(c_int, '+')) { + return 38; + } else { + return -@as(c_int, 1); + } + return 0; +} +pub extern fn get_y_previous() [*c]yankreg_T; +pub extern fn set_y_previous(yreg: [*c]yankreg_T) void; +pub extern fn get_op_type(char1: c_int, char2: c_int) c_int; +pub extern fn op_on_lines(op: c_int) c_int; +pub extern fn op_is_change(op: c_int) c_int; +pub extern fn get_op_char(optype: c_int) c_int; +pub extern fn get_extra_op_char(optype: c_int) c_int; +pub extern fn op_shift(oap: [*c]oparg_T, curs_top: c_int, amount: c_int) void; +pub extern fn shift_line(left: c_int, round: c_int, amount: c_int, call_changed_bytes: c_int) void; +pub extern fn op_reindent(oap: [*c]oparg_T, how: Indenter) void; +pub extern fn get_expr_register() c_int; +pub extern fn set_expr_line(new_line: [*c]u8) void; +pub extern fn get_expr_line() [*c]u8; +pub extern fn get_expr_line_src() [*c]u8; +pub extern fn valid_yank_reg(regname: c_int, writing: bool) bool; +pub extern fn get_yank_register(regname: c_int, mode: c_int) [*c]yankreg_T; +pub extern fn copy_register(name: c_int) [*c]yankreg_T; +pub extern fn yank_register_mline(regname: c_int) bool; +pub extern fn do_record(c: c_int) c_int; +pub extern fn do_execreg(regname: c_int, colon: c_int, addcr: c_int, silent: c_int) c_int; +pub extern fn insert_reg(regname: c_int, literally_arg: bool) c_int; +pub extern fn get_spec_reg(regname: c_int, argp: [*c][*c]u8, allocated: [*c]bool, errmsg: bool) bool; +pub extern fn cmdline_paste_reg(regname: c_int, literally_arg: bool, remcr: bool) bool; +pub extern fn op_delete(oap: [*c]oparg_T) c_int; +pub extern fn op_tilde(oap: [*c]oparg_T) void; +pub extern fn swapchar(op_type: c_int, pos: [*c]pos_T) bool; +pub extern fn op_insert(oap: [*c]oparg_T, count1: c_long) void; +pub extern fn op_change(oap: [*c]oparg_T) c_int; +pub extern fn free_register(reg: [*c]yankreg_T) void; +pub extern fn op_yank(oap: [*c]oparg_T, message: bool) bool; +pub extern fn do_put(regname: c_int, reg: [*c]yankreg_T, dir: c_int, count: c_long, flags: c_int) void; +pub extern fn adjust_cursor_eol() void; +pub extern fn preprocs_left() c_int; +pub extern fn get_register_name(num: c_int) c_int; +pub extern fn get_unname_register() c_int; +pub extern fn ex_display(eap: [*c]exarg_T) void; +pub extern fn skip_comment(line: [*c]u8, process: bool, include_space: bool, is_comment: [*c]bool) [*c]u8; +pub extern fn do_join(count: usize, insert_space: c_int, save_undo: c_int, use_formatoptions: c_int, setmark: bool) c_int; +pub extern fn op_addsub(oap: [*c]oparg_T, Prenum1: linenr_T, g_cmd: bool) void; +pub extern fn do_addsub(op_type: c_int, pos: [*c]pos_T, length: c_int, Prenum1: linenr_T) c_int; +pub extern fn get_reg_type(regname: c_int, reg_width: [*c]colnr_T) MotionType; +pub extern fn format_reg_type(reg_type: MotionType, reg_width: colnr_T, buf: [*c]u8, buf_len: usize) void; +pub extern fn get_reg_contents(regname: c_int, flags: c_int) ?*anyopaque; +pub extern fn write_reg_contents(name: c_int, str: [*c]const u8, len: isize, must_append: c_int) void; +pub extern fn write_reg_contents_lst(name: c_int, strings: [*c][*c]u8, must_append: bool, yank_type: MotionType, block_len: colnr_T) void; +pub extern fn write_reg_contents_ex(name: c_int, str: [*c]const u8, len: isize, must_append: bool, yank_type: MotionType, block_len: colnr_T) void; +pub extern fn clear_oparg(oap: [*c]oparg_T) void; +pub extern fn cursor_pos_info(dict: [*c]dict_T) void; +pub extern fn set_operatorfunc_option(errmsg: [*c][*c]const u8) void; +pub extern fn set_ref_in_opfunc(copyID: c_int) bool; +pub extern fn do_pending_operator(cap: [*c]cmdarg_T, old_col: c_int, gui_yank: bool) void; +pub extern fn get_default_register_name() c_int; +pub extern fn prepare_yankreg_from_object(reg: [*c]yankreg_T, regtype: String, lines: usize) bool; +pub extern fn finish_yankreg_from_object(reg: [*c]yankreg_T, clipboard_adjust: bool) void; +pub extern fn start_batch_changes() void; +pub extern fn end_batch_changes() void; +pub extern fn save_batch_count() c_int; +pub extern fn restore_batch_count(save_count: c_int) void; +pub extern fn op_global_reg_iter(iter: ?*const anyopaque, name: [*c]u8, reg: [*c]yankreg_T, is_unnamed: [*c]bool) ?*const anyopaque; +pub extern fn op_reg_iter(iter: ?*const anyopaque, regs: [*c]const yankreg_T, name: [*c]u8, reg: [*c]yankreg_T, is_unnamed: [*c]bool) ?*const anyopaque; +pub extern fn op_reg_amount() usize; +pub extern fn op_reg_set(name: u8, reg: yankreg_T, is_unnamed: bool) bool; +pub extern fn op_reg_get(name: u8) [*c]const yankreg_T; +pub extern fn op_reg_set_previous(name: u8) bool; +pub extern fn get_region_bytecount(buf: [*c]buf_T, start_lnum: linenr_T, end_lnum: linenr_T, start_col: colnr_T, end_col: colnr_T) bcount_t; +pub const gov_unknown: c_int = 0; +pub const gov_bool: c_int = 1; +pub const gov_number: c_int = 2; +pub const gov_string: c_int = 3; +pub const gov_hidden_bool: c_int = 4; +pub const gov_hidden_number: c_int = 5; +pub const gov_hidden_string: c_int = 6; +pub const getoption_T = c_uint; +pub extern fn set_init_tablocal() void; +pub extern fn set_init_1(clean_arg: bool) void; +pub extern fn set_number_default(name: [*c]u8, val: c_long) void; +pub extern fn set_init_2(headless: bool) void; +pub extern fn set_init_3() void; +pub extern fn set_helplang_default(lang: [*c]const u8) void; +pub extern fn set_title_defaults() void; +pub extern fn ex_set(eap: [*c]exarg_T) void; +pub extern fn do_set(arg: [*c]u8, opt_flags: c_int) c_int; +pub extern fn did_set_option(opt_idx: c_int, opt_flags: c_int, new_value: c_int, value_checked: c_int) void; +pub extern fn string_to_key(arg: [*c]u8) c_int; +pub extern fn did_set_title() void; +pub extern fn set_options_bin(oldval: c_int, newval: c_int, opt_flags: c_int) void; +pub extern fn get_shada_parameter(@"type": c_int) c_int; +pub extern fn find_shada_parameter(@"type": c_int) [*c]u8; +pub extern fn check_options() void; +pub extern fn was_set_insecurely(wp: [*c]win_T, opt: [*c]u8, opt_flags: c_int) c_int; +pub extern fn redraw_titles() void; +pub extern fn valid_name(val: [*c]const u8, allowed: [*c]const u8) bool; +pub extern fn check_blending(wp: [*c]win_T) void; +pub extern fn parse_winhl_opt(wp: [*c]win_T) bool; +pub extern fn get_option_sctx(name: [*c]const u8) [*c]sctx_T; +pub extern fn set_option_sctx_idx(opt_idx: c_int, opt_flags: c_int, script_ctx: sctx_T) void; +pub extern fn check_redraw_for(buf: [*c]buf_T, win: [*c]win_T, flags: u32) void; +pub extern fn check_redraw(flags: u32) void; +pub extern fn findoption_len(arg: [*c]const u8, len: usize) c_int; +pub extern fn is_tty_option(name: [*c]const u8) bool; +pub extern fn get_tty_option(name: [*c]const u8, value: [*c][*c]u8) bool; +pub extern fn set_tty_option(name: [*c]const u8, value: [*c]u8) bool; +pub extern fn set_tty_background(value: [*c]const u8) void; +pub extern fn findoption(arg: [*c]const u8) c_int; +pub extern fn get_option_value(name: [*c]const u8, numval: [*c]c_long, stringval: [*c][*c]u8, flagsp: [*c]u32, scope: c_int) getoption_T; +pub extern fn get_option_value_strict(name: [*c]u8, numval: [*c]i64, stringval: [*c][*c]u8, opt_type: c_int, from: ?*anyopaque) c_int; +pub extern fn get_option(opt_idx: c_int) [*c]vimoption_T; +pub extern fn set_option_value(name: [*c]const u8, number: c_long, string: [*c]const u8, opt_flags: c_int) [*c]const u8; +pub extern fn set_option_value_give_err(name: [*c]const u8, number: c_long, string: [*c]const u8, opt_flags: c_int) void; +pub extern fn is_option_allocated(name: [*c]const u8) bool; +pub extern fn is_string_option(name: [*c]const u8) bool; +pub extern fn find_key_option_len(arg_arg: [*c]const u8, len: usize, has_lt: bool) c_int; +pub extern fn ui_refresh_options() void; +pub extern fn makeset(fd: [*c]FILE, opt_flags: c_int, local_only: c_int) c_int; +pub extern fn makefoldset(fd: [*c]FILE) c_int; +pub extern fn unset_global_local_option(name: [*c]u8, from: ?*anyopaque) void; +pub extern fn get_varp_scope_from(p: [*c]vimoption_T, scope: c_int, buf: [*c]buf_T, win: [*c]win_T) [*c]u8; +pub extern fn get_varp_scope(p: [*c]vimoption_T, scope: c_int) [*c]u8; +pub extern fn get_option_varp_scope_from(opt_idx: c_int, scope: c_int, buf: [*c]buf_T, win: [*c]win_T) [*c]u8; +pub extern fn get_equalprg() [*c]u8; +pub extern fn win_copy_options(wp_from: [*c]win_T, wp_to: [*c]win_T) void; +pub extern fn copy_winopt(from: [*c]winopt_T, to: [*c]winopt_T) void; +pub extern fn check_win_options(win: [*c]win_T) void; +pub extern fn clear_winopt(wop: [*c]winopt_T) void; +pub extern fn didset_window_options(wp: [*c]win_T, valid_cursor: bool) void; +pub extern fn buf_copy_options(buf: [*c]buf_T, flags: c_int) void; +pub extern fn reset_modifiable() void; +pub extern fn set_iminsert_global(buf: [*c]buf_T) void; +pub extern fn set_imsearch_global(buf: [*c]buf_T) void; +pub extern fn set_context_in_set_cmd(xp: [*c]expand_T, arg: [*c]u8, opt_flags: c_int) void; +pub extern fn ExpandSettings(xp: [*c]expand_T, regmatch: [*c]regmatch_T, fuzzystr: [*c]u8, numMatches: [*c]c_int, matches: [*c][*c][*c]u8, can_fuzzy: bool) c_int; +pub extern fn ExpandOldSetting(numMatches: [*c]c_int, matches: [*c][*c][*c]u8) void; +pub extern fn shortmess(x: c_int) bool; +pub extern fn vimrc_found(fname: [*c]u8, envname: [*c]u8) void; +pub extern fn option_was_set(name: [*c]const u8) bool; +pub extern fn reset_option_was_set(name: [*c]const u8) void; +pub extern fn fill_breakat_flags() void; +pub extern fn fill_culopt_flags(val: [*c]u8, wp: [*c]win_T) c_int; +pub extern fn magic_isset() bool; +pub extern fn option_set_callback_func(optval: [*c]u8, optcb: [*c]Callback) c_int; +pub extern fn can_bs(what: c_int) bool; +pub extern fn get_bkc_value(buf: [*c]buf_T) c_uint; +pub extern fn get_flp_value(buf: [*c]buf_T) [*c]u8; +pub extern fn get_ve_flags() c_uint; +pub extern fn get_showbreak_value(win: [*c]win_T) [*c]u8; +pub extern fn get_fileformat(buf: [*c]const buf_T) c_int; +pub extern fn get_fileformat_force(buf: [*c]const buf_T, eap: [*c]const exarg_T) c_int; +pub extern fn default_fileformat() c_int; +pub extern fn set_fileformat(eol_style: c_int, opt_flags: c_int) void; +pub extern fn skip_to_option_part(p: [*c]const u8) [*c]u8; +pub extern fn copy_option_part(option: [*c][*c]u8, buf: [*c]u8, maxlen: usize, sep_chars: [*c]u8) usize; +pub extern fn csh_like_shell() c_int; +pub extern fn fish_like_shell() bool; +pub extern fn win_signcol_count(wp: [*c]win_T) c_int; +pub extern fn win_signcol_configured(wp: [*c]win_T, is_fixed: [*c]c_int) c_int; +pub extern fn get_winbuf_options(bufopt: c_int) [*c]dict_T; +pub extern fn get_scrolloff_value(wp: [*c]win_T) c_long; +pub extern fn get_sidescrolloff_value(wp: [*c]win_T) c_long; +pub extern fn get_vimoption(name: String, scope: c_int, buf: [*c]buf_T, win: [*c]win_T, err: [*c]Error) Dictionary; +pub extern fn get_all_vimoptions() Dictionary; +pub extern fn didset_string_options() void; +pub extern fn trigger_optionset_string(opt_idx: c_int, opt_flags: c_int, oldval: [*c]u8, oldval_l: [*c]u8, oldval_g: [*c]u8, newval: [*c]u8) void; +pub extern fn check_buf_options(buf: [*c]buf_T) void; +pub extern fn free_string_option(p: [*c]u8) void; +pub extern fn clear_string_option(pp: [*c][*c]u8) void; +pub extern fn check_string_option(pp: [*c][*c]u8) void; +pub extern fn set_string_option_direct(name: [*c]const u8, opt_idx: c_int, val: [*c]const u8, opt_flags: c_int, set_sid: c_int) void; +pub extern fn set_string_option_direct_in_win(wp: [*c]win_T, name: [*c]const u8, opt_idx: c_int, val: [*c]const u8, opt_flags: c_int, set_sid: c_int) void; +pub extern fn set_string_option(opt_idx: c_int, value: [*c]const u8, opt_flags: c_int, errbuf: [*c]u8, errbuflen: usize) [*c]const u8; +pub extern fn check_stl_option(s: [*c]u8) [*c]const u8; +pub extern fn did_set_string_option(opt_idx: c_int, varp: [*c][*c]u8, oldval: [*c]u8, errbuf: [*c]u8, errbuflen: usize, opt_flags: c_int, value_checked: [*c]c_int) [*c]const u8; +pub extern fn check_ff_value(p: [*c]u8) c_int; +pub extern fn save_clear_shm_value() void; +pub extern fn restore_shm_value() void; +pub extern fn set_chars_option(wp: [*c]win_T, varp: [*c][*c]u8, apply: bool) [*c]const u8; +pub extern fn check_chars_options() [*c]const u8; +pub const chartabsize_T = extern struct { + cts_win: [*c]win_T, + cts_line: [*c]u8, + cts_ptr: [*c]u8, + cts_has_virt_text: bool, + cts_cur_text_width: c_int, + cts_vcol: c_int, +}; +pub extern fn plines_win(wp: [*c]win_T, lnum: linenr_T, winheight: bool) c_int; +pub extern fn win_get_fill(wp: [*c]win_T, lnum: linenr_T) c_int; +pub extern fn win_may_fill(wp: [*c]win_T) bool; +pub extern fn plines_win_nofill(wp: [*c]win_T, lnum: linenr_T, winheight: bool) c_int; +pub extern fn plines_win_nofold(wp: [*c]win_T, lnum: linenr_T) c_int; +pub extern fn plines_win_col(wp: [*c]win_T, lnum: linenr_T, column: c_long) c_int; +pub extern fn plines_win_full(wp: [*c]win_T, lnum: linenr_T, nextp: [*c]linenr_T, foldedp: [*c]bool, cache: bool) c_int; +pub extern fn plines_m_win(wp: [*c]win_T, first: linenr_T, last: linenr_T) c_int; +pub extern fn win_chartabsize(wp: [*c]win_T, p: [*c]u8, col: colnr_T) c_int; +pub extern fn linetabsize(s: [*c]u8) c_int; +pub extern fn linetabsize_col(startcol: c_int, s: [*c]u8) c_int; +pub extern fn win_linetabsize(wp: [*c]win_T, lnum: linenr_T, line: [*c]u8, len: colnr_T) c_uint; +pub extern fn init_chartabsize_arg(cts: [*c]chartabsize_T, wp: [*c]win_T, lnum: linenr_T, col: colnr_T, line: [*c]u8, ptr: [*c]u8) void; +pub extern fn clear_chartabsize_arg(cts: [*c]chartabsize_T) void; +pub extern fn lbr_chartabsize(cts: [*c]chartabsize_T) c_int; +pub extern fn lbr_chartabsize_adv(cts: [*c]chartabsize_T) c_int; +pub extern fn win_lbr_chartabsize(cts: [*c]chartabsize_T, headp: [*c]c_int) c_int; +pub const pumitem_T = extern struct { + pum_text: [*c]u8, + pum_kind: [*c]u8, + pum_extra: [*c]u8, + pum_info: [*c]u8, +}; +pub extern var pum_grid: ScreenGrid; +const struct_unnamed_152 = extern struct { + active: bool, + item: c_int, + insert: bool, + finish: bool, +}; +pub extern var pum_want: struct_unnamed_152; +pub extern fn pum_display(array: [*c]pumitem_T, size: c_int, selected: c_int, array_changed: bool, cmd_startcol: c_int) void; +pub extern fn pum_redraw() void; +pub extern fn pum_undisplay(immediate: bool) void; +pub extern fn pum_check_clear() void; +pub extern fn pum_clear() void; +pub extern fn pum_visible() bool; +pub extern fn pum_drawn() bool; +pub extern fn pum_invalidate() void; +pub extern fn pum_recompose() void; +pub extern fn pum_ext_select_item(item: c_int, insert: bool, finish: bool) void; +pub extern fn pum_get_height() c_int; +pub extern fn pum_set_event_info(dict: [*c]dict_T) void; +pub extern fn pum_show_popupmenu(menu: [*c]vimmenu_T) void; +pub extern fn pum_make_popup(path_name: [*c]const u8, use_mouse_pos: c_int) void; +pub extern fn profile_start() proftime_T; +pub extern fn profile_end(tm: proftime_T) proftime_T; +pub extern fn profile_msg(tm: proftime_T) [*c]const u8; +pub extern fn profile_setlimit(msec: i64) proftime_T; +pub extern fn profile_passed_limit(tm: proftime_T) bool; +pub extern fn profile_zero() proftime_T; +pub extern fn profile_divide(tm: proftime_T, count: c_int) proftime_T; +pub extern fn profile_add(tm1: proftime_T, tm2: proftime_T) proftime_T; +pub extern fn profile_sub(tm1: proftime_T, tm2: proftime_T) proftime_T; +pub extern fn profile_self(self: proftime_T, total: proftime_T, children: proftime_T) proftime_T; +pub extern fn profile_get_wait() proftime_T; +pub extern fn profile_set_wait(wait: proftime_T) void; +pub extern fn profile_sub_wait(tm: proftime_T, tma: proftime_T) proftime_T; +pub extern fn profile_equal(tm1: proftime_T, tm2: proftime_T) bool; +pub extern fn profile_signed(tm: proftime_T) i64; +pub extern fn profile_cmp(tm1: proftime_T, tm2: proftime_T) c_int; +pub extern fn profile_reset() void; +pub extern fn ex_profile(eap: [*c]exarg_T) void; +pub extern fn get_profile_name(xp: [*c]expand_T, idx: c_int) [*c]u8; +pub extern fn set_context_in_profile_cmd(xp: [*c]expand_T, arg: [*c]const u8) void; +pub extern fn prof_inchar_enter() void; +pub extern fn prof_inchar_exit() void; +pub extern fn prof_def_func() bool; +pub extern fn func_do_profile(fp: [*c]ufunc_T) void; +pub extern fn prof_child_enter(tm: [*c]proftime_T) void; +pub extern fn prof_child_exit(tm: [*c]proftime_T) void; +pub extern fn func_line_start(cookie: ?*anyopaque) void; +pub extern fn func_line_exec(cookie: ?*anyopaque) void; +pub extern fn func_line_end(cookie: ?*anyopaque) void; +pub extern fn profile_init(si: [*c]scriptitem_T) void; +pub extern fn script_prof_save(tm: [*c]proftime_T) void; +pub extern fn script_prof_restore(tm: [*c]const proftime_T) void; +pub extern fn profile_dump() void; +pub extern fn script_line_start() void; +pub extern fn script_line_exec() void; +pub extern fn script_line_end() void; +pub extern fn time_push(rel: [*c]proftime_T, start: [*c]proftime_T) void; +pub extern fn time_pop(tp: proftime_T) void; +pub extern fn time_start(message: [*c]const u8) void; +pub extern fn time_msg(mesg: [*c]const u8, start: [*c]const proftime_T) void; +pub extern fn qf_init(wp: [*c]win_T, noalias efile: [*c]const u8, noalias errorformat: [*c]u8, newlist: c_int, noalias qf_title: [*c]const u8, noalias enc: [*c]u8) c_int; +pub extern fn qf_stack_get_bufnr() c_int; +pub extern fn qf_free_all(wp: [*c]win_T) void; +pub extern fn copy_loclist_stack(from: [*c]win_T, to: [*c]win_T) void; +pub extern fn qf_jump(qi: ?*qf_info_T, dir: c_int, errornr: c_int, forceit: c_int) void; +pub extern fn qf_list(eap: [*c]exarg_T) void; +pub extern fn qf_age(eap: [*c]exarg_T) void; +pub extern fn qf_history(eap: [*c]exarg_T) void; +pub extern fn qf_mark_adjust(wp: [*c]win_T, line1: linenr_T, line2: linenr_T, amount: linenr_T, amount_after: linenr_T) bool; +pub extern fn qf_view_result(split: bool) void; +pub extern fn ex_cwindow(eap: [*c]exarg_T) void; +pub extern fn ex_cclose(eap: [*c]exarg_T) void; +pub extern fn ex_copen(eap: [*c]exarg_T) void; +pub extern fn ex_cbottom(eap: [*c]exarg_T) void; +pub extern fn qf_current_entry(wp: [*c]win_T) linenr_T; +pub extern fn qf_process_qftf_option(errmsg: [*c][*c]const u8) void; +pub extern fn grep_internal(cmdidx: cmdidx_T) c_int; +pub extern fn ex_make(eap: [*c]exarg_T) void; +pub extern fn qf_get_size(eap: [*c]exarg_T) usize; +pub extern fn qf_get_valid_size(eap: [*c]exarg_T) usize; +pub extern fn qf_get_cur_idx(eap: [*c]exarg_T) usize; +pub extern fn qf_get_cur_valid_idx(eap: [*c]exarg_T) c_int; +pub extern fn ex_cc(eap: [*c]exarg_T) void; +pub extern fn ex_cnext(eap: [*c]exarg_T) void; +pub extern fn ex_cbelow(eap: [*c]exarg_T) void; +pub extern fn ex_cfile(eap: [*c]exarg_T) void; +pub extern fn ex_vimgrep(eap: [*c]exarg_T) void; +pub extern fn set_errorlist(wp: [*c]win_T, list: [*c]list_T, action: c_int, title: [*c]u8, what: [*c]dict_T) c_int; +pub extern fn set_ref_in_quickfix(copyID: c_int) bool; +pub extern fn ex_cbuffer(eap: [*c]exarg_T) void; +pub extern fn ex_cexpr(eap: [*c]exarg_T) void; +pub extern fn ex_helpgrep(eap: [*c]exarg_T) void; +pub extern fn f_getloclist(argvars: [*c]typval_T, rettv: [*c]typval_T, fptr: EvalFuncData) void; +pub extern fn f_getqflist(argvars: [*c]typval_T, rettv: [*c]typval_T, fptr: EvalFuncData) void; +pub extern fn f_setloclist(argvars: [*c]typval_T, rettv: [*c]typval_T, fptr: EvalFuncData) void; +pub extern fn f_setqflist(argvars: [*c]typval_T, rettv: [*c]typval_T, fptr: EvalFuncData) void; +pub extern fn re_multiline(prog: [*c]const regprog_T) c_int; +pub extern fn skip_regexp(startp: [*c]u8, delim: c_int, magic: c_int) [*c]u8; +pub extern fn skip_regexp_err(startp: [*c]u8, delim: c_int, magic: c_int) [*c]u8; +pub extern fn skip_regexp_ex(startp: [*c]u8, dirc: c_int, magic: c_int, newp: [*c][*c]u8, dropped: [*c]c_int, magic_val: [*c]magic_T) [*c]u8; +pub extern fn ref_extmatch(em: [*c]reg_extmatch_T) [*c]reg_extmatch_T; +pub extern fn unref_extmatch(em: [*c]reg_extmatch_T) void; +pub extern fn regtilde(source: [*c]u8, magic: c_int, preview: bool) [*c]u8; +pub extern fn vim_regsub(rmp: [*c]regmatch_T, source: [*c]u8, expr: [*c]typval_T, dest: [*c]u8, destlen: c_int, flags: c_int) c_int; +pub extern fn vim_regsub_multi(rmp: [*c]regmmatch_T, lnum: linenr_T, source: [*c]u8, dest: [*c]u8, destlen: c_int, flags: c_int) c_int; +pub extern fn reg_submatch(no: c_int) [*c]u8; +pub extern fn reg_submatch_list(no: c_int) [*c]list_T; +pub extern fn vim_regcomp(expr_arg: [*c]const u8, re_flags: c_int) [*c]regprog_T; +pub extern fn vim_regfree(prog: [*c]regprog_T) void; +pub extern fn vim_regexec_prog(prog: [*c][*c]regprog_T, ignore_case: bool, line: [*c]const u8, col: colnr_T) bool; +pub extern fn vim_regexec(rmp: [*c]regmatch_T, line: [*c]const u8, col: colnr_T) bool; +pub extern fn vim_regexec_nl(rmp: [*c]regmatch_T, line: [*c]const u8, col: colnr_T) bool; +pub extern fn vim_regexec_multi(rmp: [*c]regmmatch_T, win: [*c]win_T, buf: [*c]buf_T, lnum: linenr_T, col: colnr_T, tm: [*c]proftime_T, timed_out: [*c]c_int) c_long; +pub extern fn vim_regcomp_had_eol() c_int; +pub const struct_soffset = extern struct { + dir: u8, + line: bool, + end: bool, + off: i64, +}; +pub const SearchOffset = struct_soffset; +pub const struct_spat = extern struct { + pat: [*c]u8, + magic: bool, + no_scs: bool, + timestamp: Timestamp, + off: SearchOffset, + additional_data: [*c]dict_T, +}; +pub const SearchPattern = struct_spat; +pub const searchit_arg_T = extern struct { + sa_stop_lnum: linenr_T, + sa_tm: [*c]proftime_T, + sa_timed_out: c_int, + sa_wrapped: c_int, +}; +pub const struct_searchstat = extern struct { + cur: c_int, + cnt: c_int, + exact_match: bool, + incomplete: c_int, + last_maxcount: c_int, +}; +pub const searchstat_T = struct_searchstat; +pub const fuzmatch_str_T = extern struct { + idx: c_int, + str: [*c]u8, + score: c_int, +}; +pub extern fn search_regcomp(pat: [*c]u8, used_pat: [*c][*c]u8, pat_save: c_int, pat_use: c_int, options: c_int, regmatch: [*c]regmmatch_T) c_int; +pub extern fn get_search_pat() [*c]u8; +pub extern fn save_re_pat(idx: c_int, pat: [*c]u8, magic: c_int) void; +pub extern fn save_search_patterns() void; +pub extern fn restore_search_patterns() void; +pub extern fn save_last_search_pattern() void; +pub extern fn restore_last_search_pattern() void; +pub extern fn last_search_pattern() [*c]u8; +pub extern fn ignorecase(pat: [*c]u8) c_int; +pub extern fn ignorecase_opt(pat: [*c]u8, ic_in: c_int, scs: c_int) c_int; +pub extern fn pat_has_uppercase(pat: [*c]u8) bool; +pub extern fn last_csearch() [*c]const u8; +pub extern fn last_csearch_forward() c_int; +pub extern fn last_csearch_until() c_int; +pub extern fn set_last_csearch(c: c_int, s: [*c]u8, len: c_int) void; +pub extern fn set_csearch_direction(cdir: Direction) void; +pub extern fn set_csearch_until(t_cmd: c_int) void; +pub extern fn last_search_pat() [*c]u8; +pub extern fn reset_search_dir() void; +pub extern fn set_last_search_pat(s: [*c]const u8, idx: c_int, magic: c_int, setlast: c_int) void; +pub extern fn last_pat_prog(regmatch: [*c]regmmatch_T) void; +pub extern fn searchit(win: [*c]win_T, buf: [*c]buf_T, pos: [*c]pos_T, end_pos: [*c]pos_T, dir: Direction, pat: [*c]u8, count: c_long, options: c_int, pat_use: c_int, extra_arg: [*c]searchit_arg_T) c_int; +pub extern fn set_search_direction(cdir: c_int) void; +pub extern fn do_search(oap: [*c]oparg_T, dirc: c_int, search_delim: c_int, pat: [*c]u8, count: c_long, options: c_int, sia: [*c]searchit_arg_T) c_int; +pub extern fn search_for_exact_line(buf: [*c]buf_T, pos: [*c]pos_T, dir: Direction, pat: [*c]u8) c_int; +pub extern fn searchc(cap: [*c]cmdarg_T, t_cmd: c_int) c_int; +pub extern fn findmatch(oap: [*c]oparg_T, initc: c_int) [*c]pos_T; +pub extern fn findmatchlimit(oap: [*c]oparg_T, initc: c_int, flags: c_int, maxtravel: i64) [*c]pos_T; +pub extern fn check_linecomment(line: [*c]const u8) c_int; +pub extern fn showmatch(c: c_int) void; +pub extern fn current_search(count: c_long, forward: bool) c_int; +pub extern fn linewhite(lnum: linenr_T) c_int; +pub extern fn f_searchcount(argvars: [*c]typval_T, rettv: [*c]typval_T, fptr: EvalFuncData) void; +pub extern fn fuzzy_match(str: [*c]u8, pat_arg: [*c]const u8, matchseq: bool, outScore: [*c]c_int, matches: [*c]u32, maxMatches: c_int) bool; +pub extern fn f_matchfuzzy(argvars: [*c]typval_T, rettv: [*c]typval_T, fptr: EvalFuncData) void; +pub extern fn f_matchfuzzypos(argvars: [*c]typval_T, rettv: [*c]typval_T, fptr: EvalFuncData) void; +pub extern fn fuzzy_match_str(str: [*c]u8, pat: [*c]const u8) c_int; +pub extern fn fuzzymatches_to_strmatches(fuzmatch: [*c]fuzmatch_str_T, matches: [*c][*c][*c]u8, count: c_int, funcsort: bool) void; +pub extern fn fuzmatch_str_free(fuzmatch: [*c]fuzmatch_str_T, count: c_int) void; +pub extern fn find_pattern_in_path(ptr: [*c]u8, dir: Direction, len: usize, whole: bool, skip_comments: bool, @"type": c_int, count: c_long, action: c_int, start_lnum: linenr_T, end_lnum: linenr_T) void; +pub extern fn get_search_pattern(pat: [*c]SearchPattern) void; +pub extern fn get_substitute_pattern(pat: [*c]SearchPattern) void; +pub extern fn set_search_pattern(pat: SearchPattern) void; +pub extern fn set_substitute_pattern(pat: SearchPattern) void; +pub extern fn set_last_used_pattern(is_substitute_pattern: bool) void; +pub extern fn search_was_last_used() bool; +pub extern fn using_hlsearch() bool; +pub const context_sha256_T = extern struct { + total: [2]u32, + state: [8]u32, + buffer: [64]u8, +}; +pub extern fn sha256_start(ctx: [*c]context_sha256_T) void; +pub extern fn sha256_update(ctx: [*c]context_sha256_T, input: [*c]const u8, length: usize) void; +pub extern fn sha256_finish(ctx: [*c]context_sha256_T, digest: [*c]u8) void; +pub extern fn sha256_bytes(noalias buf: [*c]const u8, buf_len: usize, noalias salt: [*c]const u8, salt_len: usize) [*c]const u8; +pub extern fn sha256_self_test() bool; +pub const kShaDaWantInfo: c_int = 1; +pub const kShaDaWantMarks: c_int = 2; +pub const kShaDaForceit: c_int = 4; +pub const kShaDaGetOldfiles: c_int = 8; +pub const kShaDaMissingError: c_int = 16; +pub const ShaDaReadFileFlags = c_uint; +pub extern fn shada_write_file(file: [*c]const u8, nomerge: bool) c_int; +pub extern fn shada_read_marks() c_int; +pub extern fn shada_read_everything(fname: [*c]const u8, forceit: bool, missing_ok: bool) c_int; +pub extern fn shada_encode_regs(sbuf: [*c]msgpack_sbuffer) void; +pub extern fn shada_encode_jumps(sbuf: [*c]msgpack_sbuffer) void; +pub extern fn shada_encode_buflist(sbuf: [*c]msgpack_sbuffer) void; +pub extern fn shada_encode_gvars(sbuf: [*c]msgpack_sbuffer) void; +pub extern fn shada_read_sbuf(sbuf: [*c]msgpack_sbuffer, flags: c_int) void; +pub extern fn init_signs() void; +pub extern fn sign_get_attr(idx: c_int, sattrs: [*c]SignTextAttrs, max_signs: c_int) [*c]SignTextAttrs; +pub extern fn buf_get_signattrs(buf: [*c]buf_T, lnum: linenr_T, sattrs: [*c]SignTextAttrs, num_id: [*c]HlPriId, line_id: [*c]HlPriId, cul_id: [*c]HlPriId) c_int; +pub extern fn buf_delete_signs(buf: [*c]buf_T, group: [*c]u8) void; +pub extern fn sign_mark_adjust(line1: linenr_T, line2: linenr_T, amount: linenr_T, amount_after: linenr_T) void; +pub extern fn ex_sign(eap: [*c]exarg_T) void; +pub extern fn get_buffer_signs(buf: [*c]buf_T) [*c]list_T; +pub extern fn free_signs() void; +pub extern fn get_sign_name(xp: [*c]expand_T, idx: c_int) [*c]u8; +pub extern fn set_context_in_sign_cmd(xp: [*c]expand_T, arg: [*c]u8) void; +pub extern fn f_sign_define(argvars: [*c]typval_T, rettv: [*c]typval_T, fptr: EvalFuncData) void; +pub extern fn f_sign_getdefined(argvars: [*c]typval_T, rettv: [*c]typval_T, fptr: EvalFuncData) void; +pub extern fn f_sign_getplaced(argvars: [*c]typval_T, rettv: [*c]typval_T, fptr: EvalFuncData) void; +pub extern fn f_sign_jump(argvars: [*c]typval_T, rettv: [*c]typval_T, fptr: EvalFuncData) void; +pub extern fn f_sign_place(argvars: [*c]typval_T, rettv: [*c]typval_T, fptr: EvalFuncData) void; +pub extern fn f_sign_placelist(argvars: [*c]typval_T, rettv: [*c]typval_T, fptr: EvalFuncData) void; +pub extern fn f_sign_undefine(argvars: [*c]typval_T, rettv: [*c]typval_T, fptr: EvalFuncData) void; +pub extern fn f_sign_unplace(argvars: [*c]typval_T, rettv: [*c]typval_T, fptr: EvalFuncData) void; +pub extern fn f_sign_unplacelist(argvars: [*c]typval_T, rettv: [*c]typval_T, fptr: EvalFuncData) void; +pub const idx_T = c_int; +pub const struct_fromto_S = extern struct { + ft_from: [*c]u8, + ft_to: [*c]u8, +}; +pub const fromto_T = struct_fromto_S; +pub const struct_salitem_S = extern struct { + sm_lead: [*c]u8, + sm_leadlen: c_int, + sm_oneof: [*c]u8, + sm_rules: [*c]u8, + sm_to: [*c]u8, + sm_lead_w: [*c]c_int, + sm_oneof_w: [*c]c_int, + sm_to_w: [*c]c_int, +}; +pub const salitem_T = struct_salitem_S; +pub const salfirst_T = c_int; +pub const slang_T = struct_slang_S; +pub const struct_slang_S = extern struct { + sl_next: [*c]slang_T, + sl_name: [*c]u8, + sl_fname: [*c]u8, + sl_add: bool, + sl_fbyts: [*c]u8, + sl_fbyts_len: c_long, + sl_fidxs: [*c]idx_T, + sl_kbyts: [*c]u8, + sl_kidxs: [*c]idx_T, + sl_pbyts: [*c]u8, + sl_pidxs: [*c]idx_T, + sl_info: [*c]u8, + sl_regions: [17]u8, + sl_midword: [*c]u8, + sl_wordcount: hashtab_T, + sl_compmax: c_int, + sl_compminlen: c_int, + sl_compsylmax: c_int, + sl_compoptions: c_int, + sl_comppat: garray_T, + sl_compprog: [*c]regprog_T, + sl_comprules: [*c]u8, + sl_compstartflags: [*c]u8, + sl_compallflags: [*c]u8, + sl_nobreak: bool, + sl_syllable: [*c]u8, + sl_syl_items: garray_T, + sl_prefixcnt: c_int, + sl_prefprog: [*c][*c]regprog_T, + sl_rep: garray_T, + sl_rep_first: [256]i16, + sl_sal: garray_T, + sl_sal_first: [256]salfirst_T, + sl_followup: bool, + sl_collapse: bool, + sl_rem_accents: bool, + sl_sofo: bool, + sl_repsal: garray_T, + sl_repsal_first: [256]i16, + sl_nosplitsugs: bool, + sl_nocompoundsugs: bool, + sl_sugtime: time_t, + sl_sbyts: [*c]u8, + sl_sidxs: [*c]idx_T, + sl_sugbuf: [*c]buf_T, + sl_sugloaded: bool, + sl_has_map: bool, + sl_map_hash: hashtab_T, + sl_map_array: [256]c_int, + sl_sounddone: hashtab_T, +}; +pub const struct_langp_S = extern struct { + lp_slang: [*c]slang_T, + lp_sallang: [*c]slang_T, + lp_replang: [*c]slang_T, + lp_region: c_int, +}; +pub const langp_T = struct_langp_S; +pub const spelltab_T = extern struct { + st_isw: [256]bool, + st_isu: [256]bool, + st_fold: [256]u8, + st_upper: [256]u8, +}; +pub extern var first_lang: [*c]slang_T; +pub extern var int_wordlist: [*c]u8; +pub extern var spelltab: spelltab_T; +pub extern var did_set_spelltab: c_int; +pub extern var e_format: [*c]u8; +pub const SPELL_ADD_GOOD: c_int = 0; +pub const SPELL_ADD_BAD: c_int = 1; +pub const SPELL_ADD_RARE: c_int = 2; +pub const SpellAddType = c_uint; +pub const struct_wordcount_S = extern struct { + wc_count: u16 align(2), + pub fn wc_word(self: anytype) @import("std").zig.c_translation.FlexibleArrayType(@TypeOf(self), u8) { + const Intermediate = @import("std").zig.c_translation.FlexibleArrayType(@TypeOf(self), u8); + const ReturnType = @import("std").zig.c_translation.FlexibleArrayType(@TypeOf(self), u8); + return @ptrCast(ReturnType, @alignCast(@alignOf(u8), @ptrCast(Intermediate, self) + 2)); + } +}; +pub const wordcount_T = struct_wordcount_S; +pub extern var repl_from: [*c]u8; +pub extern var repl_to: [*c]u8; +pub extern fn spell_check(wp: [*c]win_T, ptr: [*c]u8, attrp: [*c]hlf_T, capcol: [*c]c_int, docount: bool) usize; +pub extern fn match_checkcompoundpattern(ptr: [*c]u8, wlen: c_int, gap: [*c]garray_T) bool; +pub extern fn can_compound(slang: [*c]slang_T, word: [*c]const u8, flags: [*c]const u8) bool; +pub extern fn match_compoundrule(slang: [*c]slang_T, compflags: [*c]const u8) bool; +pub extern fn valid_word_prefix(totprefcnt: c_int, arridx: c_int, flags: c_int, word: [*c]u8, slang: [*c]slang_T, cond_req: bool) c_int; +pub extern fn spell_valid_case(wordflags: c_int, treeflags: c_int) bool; +pub extern fn no_spell_checking(wp: [*c]win_T) bool; +pub extern fn spell_move_to(wp: [*c]win_T, dir: c_int, allwords: bool, curline: bool, attrp: [*c]hlf_T) usize; +pub extern fn spell_cat_line(buf: [*c]u8, line: [*c]u8, maxlen: c_int) void; +pub extern fn spell_enc() [*c]u8; +pub extern fn slang_alloc(lang: [*c]u8) [*c]slang_T; +pub extern fn slang_free(lp: [*c]slang_T) void; +pub extern fn slang_clear(lp: [*c]slang_T) void; +pub extern fn slang_clear_sug(lp: [*c]slang_T) void; +pub extern fn count_common_word(lp: [*c]slang_T, word: [*c]u8, len: c_int, count: u8) void; +pub extern fn byte_in_str(str: [*c]u8, n: c_int) bool; +pub extern fn init_syl_tab(slang: [*c]slang_T) c_int; +pub extern fn did_set_spelllang(wp: [*c]win_T) [*c]u8; +pub extern fn captype(word: [*c]u8, end: [*c]const u8) c_int; +pub extern fn spell_delete_wordlist() void; +pub extern fn spell_free_all() void; +pub extern fn spell_reload() void; +pub extern fn open_spellbuf() [*c]buf_T; +pub extern fn close_spellbuf(buf: [*c]buf_T) void; +pub extern fn clear_spell_chartab(sp: [*c]spelltab_T) void; +pub extern fn init_spell_chartab() void; +pub extern fn spell_iswordp(p: [*c]const u8, wp: [*c]const win_T) bool; +pub extern fn spell_iswordp_nmw(p: [*c]const u8, wp: [*c]win_T) bool; +pub extern fn spell_casefold(wp: [*c]const win_T, str: [*c]u8, len: c_int, buf: [*c]u8, buflen: c_int) c_int; +pub extern fn check_need_cap(lnum: linenr_T, col: colnr_T) bool; +pub extern fn ex_spellrepall(eap: [*c]exarg_T) void; +pub extern fn onecap_copy(word: [*c]u8, wcopy: [*c]u8, upper: bool) void; +pub extern fn allcap_copy(word: [*c]u8, wcopy: [*c]u8) void; +pub extern fn nofold_len(fword: [*c]u8, flen: c_int, word: [*c]u8) c_int; +pub extern fn make_case_word(fword: [*c]u8, cword: [*c]u8, flags: c_int) void; +pub extern fn eval_soundfold(word: [*c]const u8) [*c]u8; +pub extern fn spell_soundfold(slang: [*c]slang_T, inword: [*c]u8, folded: bool, res: [*c]u8) void; +pub extern fn ex_spellinfo(eap: [*c]exarg_T) void; +pub extern fn ex_spelldump(eap: [*c]exarg_T) void; +pub extern fn spell_dump_compl(pat: [*c]u8, ic: c_int, dir: [*c]Direction, dumpflags_arg: c_int) void; +pub extern fn spell_to_word_end(start: [*c]u8, win: [*c]win_T) [*c]u8; +pub extern fn spell_word_start(startcol: c_int) c_int; +pub extern fn spell_expand_check_cap(col: colnr_T) void; +pub extern fn expand_spelling(lnum: linenr_T, pat: [*c]u8, matchp: [*c][*c][*c]u8) c_int; +pub extern fn valid_spelllang(val: [*c]const u8) bool; +pub extern fn valid_spellfile(val: [*c]const u8) bool; +pub extern fn did_set_spell_option(is_spellfile: bool) [*c]const u8; +pub extern fn compile_cap_prog(synblock: [*c]synblock_T) [*c]const u8; +pub extern fn spell_load_file(fname: [*c]u8, lang: [*c]u8, old_lp: [*c]slang_T, silent: bool) [*c]slang_T; +pub extern fn suggest_load_files() void; +pub extern fn spell_check_msm() c_int; +pub extern fn ex_mkspell(eap: [*c]exarg_T) void; +pub extern fn ex_spell(eap: [*c]exarg_T) void; +pub extern fn spell_add_word(word: [*c]u8, len: c_int, what: SpellAddType, idx: c_int, undo: bool) void; +pub extern fn spell_check_sps() c_int; +pub extern fn spell_suggest(count: c_int) void; +pub extern fn spell_suggest_list(gap: [*c]garray_T, word: [*c]u8, maxcount: c_int, need_cap: bool, interactive: bool) void; +pub const VimState = struct_vim_state; +pub const state_check_callback = ?*const fn ([*c]VimState) callconv(.C) c_int; +pub const state_execute_callback = ?*const fn ([*c]VimState, c_int) callconv(.C) c_int; +pub const struct_vim_state = extern struct { + check: state_check_callback, + execute: state_execute_callback, +}; +pub extern fn state_enter(s: [*c]VimState) void; +pub extern fn state_handle_k_event() void; +pub extern fn virtual_active() bool; +pub extern fn get_real_state() c_int; +pub extern fn get_mode(buf: [*c]u8) void; +pub extern fn may_trigger_modechanged() void; +pub extern var tab_page_click_defs: [*c]StlClickDefinition; +pub extern var tab_page_click_defs_size: usize; +pub extern fn win_redr_status(wp: [*c]win_T) void; +pub extern fn get_trans_bufname(buf: [*c]buf_T) void; +pub extern fn stl_connected(wp: [*c]win_T) bool; +pub extern fn stl_clear_click_defs(click_defs: [*c]StlClickDefinition, click_defs_size: usize) void; +pub extern fn stl_alloc_click_defs(cdp: [*c]StlClickDefinition, width: c_long, size: [*c]usize) [*c]StlClickDefinition; +pub extern fn stl_fill_click_defs(click_defs: [*c]StlClickDefinition, click_recs: [*c]StlClickRecord, buf: [*c]u8, width: c_int, tabline: bool) void; +pub extern fn win_redr_winbar(wp: [*c]win_T) void; +pub extern fn win_redr_ruler(wp: [*c]win_T) void; +pub extern fn fillchar_status(attr: [*c]c_int, wp: [*c]win_T) c_int; +pub extern fn redraw_custom_statusline(wp: [*c]win_T) void; +pub extern fn draw_tabline() void; +pub extern fn build_statuscol_str(wp: [*c]win_T, lnum: linenr_T, relnum: c_long, stcp: [*c]statuscol_T) c_int; +pub extern fn build_stl_str_hl(wp: [*c]win_T, out: [*c]u8, outlen: usize, fmt: [*c]u8, opt_name: [*c]u8, opt_scope: c_int, fillchar: c_int, maxwidth: c_int, hltab: [*c][*c]stl_hlrec_t, tabtab: [*c][*c]StlClickRecord, stcp: [*c]statuscol_T) c_int; +pub const highlight_init_cmdline: [*c]const [*c]const u8 = @extern([*c]const [*c]const u8, .{ + .name = "highlight_init_cmdline", +}); +pub extern fn syn_set_timeout(tm: [*c]proftime_T) void; +pub extern fn syntax_start(wp: [*c]win_T, lnum: linenr_T) void; +pub extern fn syn_stack_free_all(block: [*c]synblock_T) void; +pub extern fn syn_stack_apply_changes(buf: [*c]buf_T) void; +pub extern fn syntax_end_parsing(wp: [*c]win_T, lnum: linenr_T) void; +pub extern fn syntax_check_changed(lnum: linenr_T) bool; +pub extern fn get_syntax_attr(col: colnr_T, can_spell: [*c]bool, keep_state: bool) c_int; +pub extern fn syntax_clear(block: [*c]synblock_T) void; +pub extern fn reset_synblock(wp: [*c]win_T) void; +pub extern fn syn_maybe_enable() void; +pub extern fn ex_syntax(eap: [*c]exarg_T) void; +pub extern fn ex_ownsyntax(eap: [*c]exarg_T) void; +pub extern fn syntax_present(win: [*c]win_T) bool; +pub extern fn reset_expand_highlight() void; +pub extern fn set_context_in_echohl_cmd(xp: [*c]expand_T, arg: [*c]const u8) void; +pub extern fn set_context_in_syntax_cmd(xp: [*c]expand_T, arg: [*c]const u8) void; +pub extern fn get_syntax_name(xp: [*c]expand_T, idx: c_int) [*c]u8; +pub extern fn syn_get_id(wp: [*c]win_T, lnum: linenr_T, col: colnr_T, trans: c_int, spellp: [*c]bool, keep_state: c_int) c_int; +pub extern fn get_syntax_info(seqnrp: [*c]c_int) c_int; +pub extern fn syn_get_concealed_id(wp: [*c]win_T, lnum: linenr_T, col: colnr_T) c_int; +pub extern fn syn_get_sub_char() c_int; +pub extern fn syn_get_stack_item(i: c_int) c_int; +pub extern fn syn_get_foldlevel(wp: [*c]win_T, lnum: linenr_T) c_int; +pub extern fn ex_syntime(eap: [*c]exarg_T) void; +pub extern fn get_syntime_arg(xp: [*c]expand_T, idx: c_int) [*c]u8; +pub const tagname_T = extern struct { + tn_tags: [*c]u8, + tn_np: [*c]u8, + tn_did_filefind_init: c_int, + tn_hf_idx: c_int, + tn_search_ctx: ?*anyopaque, +}; +pub extern fn set_tagfunc_option(errmsg: [*c][*c]const u8) void; +pub extern fn set_ref_in_tagfunc(copyID: c_int) bool; +pub extern fn set_buflocal_tfu_callback(buf: [*c]buf_T) void; +pub extern fn do_tag(tag: [*c]u8, @"type": c_int, count: c_int, forceit: c_int, verbose: c_int) void; +pub extern fn tag_freematch() void; +pub extern fn do_tags(eap: [*c]exarg_T) void; +pub extern fn find_tags(pat: [*c]u8, num_matches: [*c]c_int, matchesp: [*c][*c][*c]u8, flags: c_int, mincount: c_int, buf_ffname: [*c]u8) c_int; +pub extern fn get_tagfname(tnp: [*c]tagname_T, first: c_int, buf: [*c]u8) c_int; +pub extern fn tagname_free(tnp: [*c]tagname_T) void; +pub extern fn expand_tags(tagnames: c_int, pat: [*c]u8, num_file: [*c]c_int, file: [*c][*c][*c]u8) c_int; +pub extern fn get_tags(list: [*c]list_T, pat: [*c]u8, buf_fname: [*c]u8) c_int; +pub extern fn get_tagstack(wp: [*c]win_T, retdict: [*c]dict_T) void; +pub extern fn set_tagstack(wp: [*c]win_T, d: [*c]const dict_T, action: c_int) c_int; +pub extern fn f_assert_beeps(argvars: [*c]typval_T, rettv: [*c]typval_T, fptr: EvalFuncData) void; +pub extern fn f_assert_nobeep(argvars: [*c]typval_T, rettv: [*c]typval_T, fptr: EvalFuncData) void; +pub extern fn f_assert_equal(argvars: [*c]typval_T, rettv: [*c]typval_T, fptr: EvalFuncData) void; +pub extern fn f_assert_equalfile(argvars: [*c]typval_T, rettv: [*c]typval_T, fptr: EvalFuncData) void; +pub extern fn f_assert_notequal(argvars: [*c]typval_T, rettv: [*c]typval_T, fptr: EvalFuncData) void; +pub extern fn f_assert_exception(argvars: [*c]typval_T, rettv: [*c]typval_T, fptr: EvalFuncData) void; +pub extern fn f_assert_fails(argvars: [*c]typval_T, rettv: [*c]typval_T, fptr: EvalFuncData) void; +pub extern fn f_assert_false(argvars: [*c]typval_T, rettv: [*c]typval_T, fptr: EvalFuncData) void; +pub extern fn f_assert_inrange(argvars: [*c]typval_T, rettv: [*c]typval_T, fptr: EvalFuncData) void; +pub extern fn f_assert_match(argvars: [*c]typval_T, rettv: [*c]typval_T, fptr: EvalFuncData) void; +pub extern fn f_assert_notmatch(argvars: [*c]typval_T, rettv: [*c]typval_T, fptr: EvalFuncData) void; +pub extern fn f_assert_report(argvars: [*c]typval_T, rettv: [*c]typval_T, fptr: EvalFuncData) void; +pub extern fn f_assert_true(argvars: [*c]typval_T, rettv: [*c]typval_T, fptr: EvalFuncData) void; +pub extern fn f_test_garbagecollect_now(argvars: [*c]typval_T, rettv: [*c]typval_T, fptr: EvalFuncData) void; +pub extern fn f_test_write_list_log(argvars: [*c]typval_T, rettv: [*c]typval_T, fptr: EvalFuncData) void; +pub extern fn has_format_option(x: c_int) bool; +pub extern fn internal_format(textwidth: c_int, second_indent: c_int, flags: c_int, format_only: bool, c: c_int) void; +pub extern fn auto_format(trailblank: bool, prev_line: bool) void; +pub extern fn check_auto_format(end_insert: bool) void; +pub extern fn comp_textwidth(ff: bool) c_int; +pub extern fn op_format(oap: [*c]oparg_T, keep_cursor: bool) void; +pub extern fn op_formatexpr(oap: [*c]oparg_T) void; +pub extern fn fex_format(lnum: linenr_T, count: c_long, c: c_int) c_int; +pub extern fn format_lines(line_count: linenr_T, avoid_fex: bool) void; +pub extern fn findsent(dir: Direction, count: c_long) c_int; +pub extern fn findpar(pincl: [*c]bool, dir: c_int, count: c_long, what: c_int, both: bool) bool; +pub extern fn startPS(lnum: linenr_T, para: c_int, both: bool) bool; +pub extern fn fwd_word(count: c_long, bigword: bool, eol: bool) c_int; +pub extern fn bck_word(count: c_long, bigword: bool, stop: bool) c_int; +pub extern fn end_word(count: c_long, bigword: bool, stop: bool, empty: bool) c_int; +pub extern fn bckend_word(count: c_long, bigword: bool, eol: bool) c_int; +pub extern fn current_word(oap: [*c]oparg_T, count: c_long, include: bool, bigword: bool) c_int; +pub extern fn current_sent(oap: [*c]oparg_T, count: c_long, include: bool) c_int; +pub extern fn current_block(oap: [*c]oparg_T, count: c_long, include: bool, what: c_int, other: c_int) c_int; +pub extern fn current_tagblock(oap: [*c]oparg_T, count_arg: c_long, include: bool) c_int; +pub extern fn current_par(oap: [*c]oparg_T, count: c_long, include: bool, @"type": c_int) c_int; +pub extern fn current_quote(oap: [*c]oparg_T, count: c_long, include: bool, quotechar: c_int) bool; +pub const TERMKEY_SYM_UNKNOWN: c_int = -1; +pub const TERMKEY_SYM_NONE: c_int = 0; +pub const TERMKEY_SYM_BACKSPACE: c_int = 1; +pub const TERMKEY_SYM_TAB: c_int = 2; +pub const TERMKEY_SYM_ENTER: c_int = 3; +pub const TERMKEY_SYM_ESCAPE: c_int = 4; +pub const TERMKEY_SYM_SPACE: c_int = 5; +pub const TERMKEY_SYM_DEL: c_int = 6; +pub const TERMKEY_SYM_UP: c_int = 7; +pub const TERMKEY_SYM_DOWN: c_int = 8; +pub const TERMKEY_SYM_LEFT: c_int = 9; +pub const TERMKEY_SYM_RIGHT: c_int = 10; +pub const TERMKEY_SYM_BEGIN: c_int = 11; +pub const TERMKEY_SYM_FIND: c_int = 12; +pub const TERMKEY_SYM_INSERT: c_int = 13; +pub const TERMKEY_SYM_DELETE: c_int = 14; +pub const TERMKEY_SYM_SELECT: c_int = 15; +pub const TERMKEY_SYM_PAGEUP: c_int = 16; +pub const TERMKEY_SYM_PAGEDOWN: c_int = 17; +pub const TERMKEY_SYM_HOME: c_int = 18; +pub const TERMKEY_SYM_END: c_int = 19; +pub const TERMKEY_SYM_CANCEL: c_int = 20; +pub const TERMKEY_SYM_CLEAR: c_int = 21; +pub const TERMKEY_SYM_CLOSE: c_int = 22; +pub const TERMKEY_SYM_COMMAND: c_int = 23; +pub const TERMKEY_SYM_COPY: c_int = 24; +pub const TERMKEY_SYM_EXIT: c_int = 25; +pub const TERMKEY_SYM_HELP: c_int = 26; +pub const TERMKEY_SYM_MARK: c_int = 27; +pub const TERMKEY_SYM_MESSAGE: c_int = 28; +pub const TERMKEY_SYM_MOVE: c_int = 29; +pub const TERMKEY_SYM_OPEN: c_int = 30; +pub const TERMKEY_SYM_OPTIONS: c_int = 31; +pub const TERMKEY_SYM_PRINT: c_int = 32; +pub const TERMKEY_SYM_REDO: c_int = 33; +pub const TERMKEY_SYM_REFERENCE: c_int = 34; +pub const TERMKEY_SYM_REFRESH: c_int = 35; +pub const TERMKEY_SYM_REPLACE: c_int = 36; +pub const TERMKEY_SYM_RESTART: c_int = 37; +pub const TERMKEY_SYM_RESUME: c_int = 38; +pub const TERMKEY_SYM_SAVE: c_int = 39; +pub const TERMKEY_SYM_SUSPEND: c_int = 40; +pub const TERMKEY_SYM_UNDO: c_int = 41; +pub const TERMKEY_SYM_KP0: c_int = 42; +pub const TERMKEY_SYM_KP1: c_int = 43; +pub const TERMKEY_SYM_KP2: c_int = 44; +pub const TERMKEY_SYM_KP3: c_int = 45; +pub const TERMKEY_SYM_KP4: c_int = 46; +pub const TERMKEY_SYM_KP5: c_int = 47; +pub const TERMKEY_SYM_KP6: c_int = 48; +pub const TERMKEY_SYM_KP7: c_int = 49; +pub const TERMKEY_SYM_KP8: c_int = 50; +pub const TERMKEY_SYM_KP9: c_int = 51; +pub const TERMKEY_SYM_KPENTER: c_int = 52; +pub const TERMKEY_SYM_KPPLUS: c_int = 53; +pub const TERMKEY_SYM_KPMINUS: c_int = 54; +pub const TERMKEY_SYM_KPMULT: c_int = 55; +pub const TERMKEY_SYM_KPDIV: c_int = 56; +pub const TERMKEY_SYM_KPCOMMA: c_int = 57; +pub const TERMKEY_SYM_KPPERIOD: c_int = 58; +pub const TERMKEY_SYM_KPEQUALS: c_int = 59; +pub const TERMKEY_N_SYMS: c_int = 60; +pub const TermKeySym = c_int; +pub const TERMKEY_TYPE_UNICODE: c_int = 0; +pub const TERMKEY_TYPE_FUNCTION: c_int = 1; +pub const TERMKEY_TYPE_KEYSYM: c_int = 2; +pub const TERMKEY_TYPE_MOUSE: c_int = 3; +pub const TERMKEY_TYPE_POSITION: c_int = 4; +pub const TERMKEY_TYPE_MODEREPORT: c_int = 5; +pub const TERMKEY_TYPE_DCS: c_int = 6; +pub const TERMKEY_TYPE_OSC: c_int = 7; +pub const TERMKEY_TYPE_UNKNOWN_CSI: c_int = -1; +pub const TermKeyType = c_int; +pub const TERMKEY_RES_NONE: c_int = 0; +pub const TERMKEY_RES_KEY: c_int = 1; +pub const TERMKEY_RES_EOF: c_int = 2; +pub const TERMKEY_RES_AGAIN: c_int = 3; +pub const TERMKEY_RES_ERROR: c_int = 4; +pub const TermKeyResult = c_uint; +pub const TERMKEY_MOUSE_UNKNOWN: c_int = 0; +pub const TERMKEY_MOUSE_PRESS: c_int = 1; +pub const TERMKEY_MOUSE_DRAG: c_int = 2; +pub const TERMKEY_MOUSE_RELEASE: c_int = 3; +pub const TermKeyMouseEvent = c_uint; +pub const TERMKEY_KEYMOD_SHIFT: c_int = 1; +pub const TERMKEY_KEYMOD_ALT: c_int = 2; +pub const TERMKEY_KEYMOD_CTRL: c_int = 4; +const enum_unnamed_153 = c_uint; +const union_unnamed_154 = extern union { + codepoint: c_long, + number: c_int, + sym: TermKeySym, + mouse: [4]u8, +}; +pub const TermKeyKey = extern struct { + type: TermKeyType, + code: union_unnamed_154, + modifiers: c_int, + utf8: [7]u8, +}; +pub const struct_TermKey = opaque {}; +pub const TermKey = struct_TermKey; +pub const TERMKEY_FLAG_NOINTERPRET: c_int = 1; +pub const TERMKEY_FLAG_CONVERTKP: c_int = 2; +pub const TERMKEY_FLAG_RAW: c_int = 4; +pub const TERMKEY_FLAG_UTF8: c_int = 8; +pub const TERMKEY_FLAG_NOTERMIOS: c_int = 16; +pub const TERMKEY_FLAG_SPACESYMBOL: c_int = 32; +pub const TERMKEY_FLAG_CTRLC: c_int = 64; +pub const TERMKEY_FLAG_EINTR: c_int = 128; +pub const TERMKEY_FLAG_NOSTART: c_int = 256; +const enum_unnamed_155 = c_uint; +pub const TERMKEY_CANON_SPACESYMBOL: c_int = 1; +pub const TERMKEY_CANON_DELBS: c_int = 2; +const enum_unnamed_156 = c_uint; +pub extern fn termkey_check_version(major: c_int, minor: c_int) void; +pub extern fn termkey_new(fd: c_int, flags: c_int) ?*TermKey; +pub extern fn termkey_new_abstract(term: [*c]const u8, flags: c_int) ?*TermKey; +pub extern fn termkey_free(tk: ?*TermKey) void; +pub extern fn termkey_destroy(tk: ?*TermKey) void; +pub const TermKey_Terminfo_Getstr_Hook = fn ([*c]const u8, [*c]const u8, ?*anyopaque) callconv(.C) [*c]const u8; +pub extern fn termkey_hook_terminfo_getstr(tk: ?*TermKey, hookfn: ?*const TermKey_Terminfo_Getstr_Hook, data: ?*anyopaque) void; +pub extern fn termkey_start(tk: ?*TermKey) c_int; +pub extern fn termkey_stop(tk: ?*TermKey) c_int; +pub extern fn termkey_is_started(tk: ?*TermKey) c_int; +pub extern fn termkey_get_fd(tk: ?*TermKey) c_int; +pub extern fn termkey_get_flags(tk: ?*TermKey) c_int; +pub extern fn termkey_set_flags(tk: ?*TermKey, newflags: c_int) void; +pub extern fn termkey_get_waittime(tk: ?*TermKey) c_int; +pub extern fn termkey_set_waittime(tk: ?*TermKey, msec: c_int) void; +pub extern fn termkey_get_canonflags(tk: ?*TermKey) c_int; +pub extern fn termkey_set_canonflags(tk: ?*TermKey, c_int) void; +pub extern fn termkey_get_buffer_size(tk: ?*TermKey) usize; +pub extern fn termkey_set_buffer_size(tk: ?*TermKey, size: usize) c_int; +pub extern fn termkey_get_buffer_remaining(tk: ?*TermKey) usize; +pub extern fn termkey_canonicalise(tk: ?*TermKey, key: [*c]TermKeyKey) void; +pub extern fn termkey_getkey(tk: ?*TermKey, key: [*c]TermKeyKey) TermKeyResult; +pub extern fn termkey_getkey_force(tk: ?*TermKey, key: [*c]TermKeyKey) TermKeyResult; +pub extern fn termkey_waitkey(tk: ?*TermKey, key: [*c]TermKeyKey) TermKeyResult; +pub extern fn termkey_advisereadable(tk: ?*TermKey) TermKeyResult; +pub extern fn termkey_push_bytes(tk: ?*TermKey, bytes: [*c]const u8, len: usize) usize; +pub extern fn termkey_register_keyname(tk: ?*TermKey, sym: TermKeySym, name: [*c]const u8) TermKeySym; +pub extern fn termkey_get_keyname(tk: ?*TermKey, sym: TermKeySym) [*c]const u8; +pub extern fn termkey_lookup_keyname(tk: ?*TermKey, str: [*c]const u8, sym: [*c]TermKeySym) [*c]const u8; +pub extern fn termkey_keyname2sym(tk: ?*TermKey, keyname: [*c]const u8) TermKeySym; +pub extern fn termkey_interpret_mouse(tk: ?*TermKey, key: [*c]const TermKeyKey, event: [*c]TermKeyMouseEvent, button: [*c]c_int, line: [*c]c_int, col: [*c]c_int) TermKeyResult; +pub extern fn termkey_interpret_position(tk: ?*TermKey, key: [*c]const TermKeyKey, line: [*c]c_int, col: [*c]c_int) TermKeyResult; +pub extern fn termkey_interpret_modereport(tk: ?*TermKey, key: [*c]const TermKeyKey, initial: [*c]c_int, mode: [*c]c_int, value: [*c]c_int) TermKeyResult; +pub extern fn termkey_interpret_csi(tk: ?*TermKey, key: [*c]const TermKeyKey, args: [*c]c_long, nargs: [*c]usize, cmd: [*c]c_ulong) TermKeyResult; +pub extern fn termkey_interpret_string(tk: ?*TermKey, key: [*c]const TermKeyKey, strp: [*c][*c]const u8) TermKeyResult; +pub const TERMKEY_FORMAT_LONGMOD: c_int = 1; +pub const TERMKEY_FORMAT_CARETCTRL: c_int = 2; +pub const TERMKEY_FORMAT_ALTISMETA: c_int = 4; +pub const TERMKEY_FORMAT_WRAPBRACKET: c_int = 8; +pub const TERMKEY_FORMAT_SPACEMOD: c_int = 16; +pub const TERMKEY_FORMAT_LOWERMOD: c_int = 32; +pub const TERMKEY_FORMAT_LOWERSPACE: c_int = 64; +pub const TERMKEY_FORMAT_MOUSE_POS: c_int = 256; +pub const TermKeyFormat = c_uint; +pub extern fn termkey_strfkey(tk: ?*TermKey, buffer: [*c]u8, len: usize, key: [*c]TermKeyKey, format: TermKeyFormat) usize; +pub extern fn termkey_strpkey(tk: ?*TermKey, str: [*c]const u8, key: [*c]TermKeyKey, format: TermKeyFormat) [*c]const u8; +pub extern fn termkey_keycmp(tk: ?*TermKey, key1: [*c]const TermKeyKey, key2: [*c]const TermKeyKey) c_int; +pub const struct_TUIData = opaque {}; +pub const TUIData = struct_TUIData; +pub extern fn tui_start(tui_p: [*c]?*TUIData, width: [*c]c_int, height: [*c]c_int, term: [*c][*c]u8) void; +pub extern fn tui_enable_extkeys(tui: ?*TUIData) void; +pub extern fn tui_stop(tui: ?*TUIData) void; +pub extern fn tui_is_stopped(tui: ?*TUIData) bool; +pub extern fn tui_grid_resize(tui: ?*TUIData, g: Integer, width: Integer, height: Integer) void; +pub extern fn tui_grid_clear(tui: ?*TUIData, g: Integer) void; +pub extern fn tui_grid_cursor_goto(tui: ?*TUIData, grid: Integer, row: Integer, col: Integer) void; +pub extern fn tui_cursor_decode_shape(shape_str: [*c]const u8) CursorShape; +pub extern fn tui_mode_info_set(tui: ?*TUIData, guicursor_enabled: bool, args: Array) void; +pub extern fn tui_update_menu(tui: ?*TUIData) void; +pub extern fn tui_busy_start(tui: ?*TUIData) void; +pub extern fn tui_busy_stop(tui: ?*TUIData) void; +pub extern fn tui_mouse_on(tui: ?*TUIData) void; +pub extern fn tui_mouse_off(tui: ?*TUIData) void; +pub extern fn tui_set_mode(tui: ?*TUIData, mode: ModeShape) void; +pub extern fn tui_mode_change(tui: ?*TUIData, mode: String, mode_idx: Integer) void; +pub extern fn tui_grid_scroll(tui: ?*TUIData, g: Integer, startrow: Integer, endrow: Integer, startcol: Integer, endcol: Integer, rows: Integer, cols: Integer) void; +pub extern fn tui_hl_attr_define(tui: ?*TUIData, id: Integer, attrs: HlAttrs, cterm_attrs: HlAttrs, info: Array) void; +pub extern fn tui_bell(tui: ?*TUIData) void; +pub extern fn tui_visual_bell(tui: ?*TUIData) void; +pub extern fn tui_default_colors_set(tui: ?*TUIData, rgb_fg: Integer, rgb_bg: Integer, rgb_sp: Integer, cterm_fg: Integer, cterm_bg: Integer) void; +pub extern fn tui_flush(tui: ?*TUIData) void; +pub extern fn tui_suspend(tui: ?*TUIData) void; +pub extern fn tui_set_title(tui: ?*TUIData, title: String) void; +pub extern fn tui_set_icon(tui: ?*TUIData, icon: String) void; +pub extern fn tui_screenshot(tui: ?*TUIData, path: String) void; +pub extern fn tui_option_set(tui: ?*TUIData, name: String, value: Object) void; +pub extern fn tui_raw_line(tui: ?*TUIData, g: Integer, linerow: Integer, startcol: Integer, endcol: Integer, clearcol: Integer, clearattr: Integer, flags: LineFlags, chunk: [*c]const schar_T, attrs: [*c]const sattr_T) void; +pub extern fn tui_guess_size(tui: ?*TUIData) void; +pub const kExtkeysNone: c_int = 0; +pub const kExtkeysCSIu: c_int = 1; +pub const kExtkeysXterm: c_int = 2; +pub const ExtkeysType = c_uint; +pub const struct_term_input = extern struct { + in_fd: c_int, + paste: i8, + ttimeout: bool, + waiting_for_bg_response: i8, + waiting_for_csiu_response: i8, + extkeys_type: ExtkeysType, + ttimeoutlen: c_long, + tk: ?*TermKey, + tk_ti_hook_fn: ?*const TermKey_Terminfo_Getstr_Hook, + timer_handle: TimeWatcher, + loop: [*c]Loop, + read_stream: Stream, + key_buffer: [*c]RBuffer, + tui_data: ?*TUIData, +}; +pub const TermInput = struct_term_input; +pub const kIncomplete: c_int = -1; +pub const kNotApplicable: c_int = 0; +pub const kComplete: c_int = 1; +pub const HandleState = c_int; +pub extern fn tinput_init(input: [*c]TermInput, loop: [*c]Loop) void; +pub extern fn tinput_destroy(input: [*c]TermInput) void; +pub extern fn tinput_start(input: [*c]TermInput) void; +pub extern fn tinput_stop(input: [*c]TermInput) void; +pub extern fn handle_background_color(input: [*c]TermInput) HandleState; +pub const unibi_boolean_begin_: c_int = 0; +pub const unibi_auto_left_margin: c_int = 1; +pub const unibi_auto_right_margin: c_int = 2; +pub const unibi_no_esc_ctlc: c_int = 3; +pub const unibi_ceol_standout_glitch: c_int = 4; +pub const unibi_eat_newline_glitch: c_int = 5; +pub const unibi_erase_overstrike: c_int = 6; +pub const unibi_generic_type: c_int = 7; +pub const unibi_hard_copy: c_int = 8; +pub const unibi_has_meta_key: c_int = 9; +pub const unibi_has_status_line: c_int = 10; +pub const unibi_insert_null_glitch: c_int = 11; +pub const unibi_memory_above: c_int = 12; +pub const unibi_memory_below: c_int = 13; +pub const unibi_move_insert_mode: c_int = 14; +pub const unibi_move_standout_mode: c_int = 15; +pub const unibi_over_strike: c_int = 16; +pub const unibi_status_line_esc_ok: c_int = 17; +pub const unibi_dest_tabs_magic_smso: c_int = 18; +pub const unibi_tilde_glitch: c_int = 19; +pub const unibi_transparent_underline: c_int = 20; +pub const unibi_xon_xoff: c_int = 21; +pub const unibi_needs_xon_xoff: c_int = 22; +pub const unibi_prtr_silent: c_int = 23; +pub const unibi_hard_cursor: c_int = 24; +pub const unibi_non_rev_rmcup: c_int = 25; +pub const unibi_no_pad_char: c_int = 26; +pub const unibi_non_dest_scroll_region: c_int = 27; +pub const unibi_can_change: c_int = 28; +pub const unibi_back_color_erase: c_int = 29; +pub const unibi_hue_lightness_saturation: c_int = 30; +pub const unibi_col_addr_glitch: c_int = 31; +pub const unibi_cr_cancels_micro_mode: c_int = 32; +pub const unibi_has_print_wheel: c_int = 33; +pub const unibi_row_addr_glitch: c_int = 34; +pub const unibi_semi_auto_right_margin: c_int = 35; +pub const unibi_cpi_changes_res: c_int = 36; +pub const unibi_lpi_changes_res: c_int = 37; +pub const unibi_backspaces_with_bs: c_int = 38; +pub const unibi_crt_no_scrolling: c_int = 39; +pub const unibi_no_correctly_working_cr: c_int = 40; +pub const unibi_gnu_has_meta_key: c_int = 41; +pub const unibi_linefeed_is_newline: c_int = 42; +pub const unibi_has_hardware_tabs: c_int = 43; +pub const unibi_return_does_clr_eol: c_int = 44; +pub const unibi_boolean_end_: c_int = 45; +pub const enum_unibi_boolean = c_uint; +pub const unibi_numeric_begin_: c_int = 45; +pub const unibi_columns: c_int = 46; +pub const unibi_init_tabs: c_int = 47; +pub const unibi_lines: c_int = 48; +pub const unibi_lines_of_memory: c_int = 49; +pub const unibi_magic_cookie_glitch: c_int = 50; +pub const unibi_padding_baud_rate: c_int = 51; +pub const unibi_virtual_terminal: c_int = 52; +pub const unibi_width_status_line: c_int = 53; +pub const unibi_num_labels: c_int = 54; +pub const unibi_label_height: c_int = 55; +pub const unibi_label_width: c_int = 56; +pub const unibi_max_attributes: c_int = 57; +pub const unibi_maximum_windows: c_int = 58; +pub const unibi_max_colors: c_int = 59; +pub const unibi_max_pairs: c_int = 60; +pub const unibi_no_color_video: c_int = 61; +pub const unibi_buffer_capacity: c_int = 62; +pub const unibi_dot_vert_spacing: c_int = 63; +pub const unibi_dot_horz_spacing: c_int = 64; +pub const unibi_max_micro_address: c_int = 65; +pub const unibi_max_micro_jump: c_int = 66; +pub const unibi_micro_col_size: c_int = 67; +pub const unibi_micro_line_size: c_int = 68; +pub const unibi_number_of_pins: c_int = 69; +pub const unibi_output_res_char: c_int = 70; +pub const unibi_output_res_line: c_int = 71; +pub const unibi_output_res_horz_inch: c_int = 72; +pub const unibi_output_res_vert_inch: c_int = 73; +pub const unibi_print_rate: c_int = 74; +pub const unibi_wide_char_size: c_int = 75; +pub const unibi_buttons: c_int = 76; +pub const unibi_bit_image_entwining: c_int = 77; +pub const unibi_bit_image_type: c_int = 78; +pub const unibi_magic_cookie_glitch_ul: c_int = 79; +pub const unibi_carriage_return_delay: c_int = 80; +pub const unibi_new_line_delay: c_int = 81; +pub const unibi_backspace_delay: c_int = 82; +pub const unibi_horizontal_tab_delay: c_int = 83; +pub const unibi_number_of_function_keys: c_int = 84; +pub const unibi_numeric_end_: c_int = 85; +pub const enum_unibi_numeric = c_uint; +pub const unibi_string_begin_: c_int = 85; +pub const unibi_back_tab: c_int = 86; +pub const unibi_bell: c_int = 87; +pub const unibi_carriage_return: c_int = 88; +pub const unibi_change_scroll_region: c_int = 89; +pub const unibi_clear_all_tabs: c_int = 90; +pub const unibi_clear_screen: c_int = 91; +pub const unibi_clr_eol: c_int = 92; +pub const unibi_clr_eos: c_int = 93; +pub const unibi_column_address: c_int = 94; +pub const unibi_command_character: c_int = 95; +pub const unibi_cursor_address: c_int = 96; +pub const unibi_cursor_down: c_int = 97; +pub const unibi_cursor_home: c_int = 98; +pub const unibi_cursor_invisible: c_int = 99; +pub const unibi_cursor_left: c_int = 100; +pub const unibi_cursor_mem_address: c_int = 101; +pub const unibi_cursor_normal: c_int = 102; +pub const unibi_cursor_right: c_int = 103; +pub const unibi_cursor_to_ll: c_int = 104; +pub const unibi_cursor_up: c_int = 105; +pub const unibi_cursor_visible: c_int = 106; +pub const unibi_delete_character: c_int = 107; +pub const unibi_delete_line: c_int = 108; +pub const unibi_dis_status_line: c_int = 109; +pub const unibi_down_half_line: c_int = 110; +pub const unibi_enter_alt_charset_mode: c_int = 111; +pub const unibi_enter_blink_mode: c_int = 112; +pub const unibi_enter_bold_mode: c_int = 113; +pub const unibi_enter_ca_mode: c_int = 114; +pub const unibi_enter_delete_mode: c_int = 115; +pub const unibi_enter_dim_mode: c_int = 116; +pub const unibi_enter_insert_mode: c_int = 117; +pub const unibi_enter_secure_mode: c_int = 118; +pub const unibi_enter_protected_mode: c_int = 119; +pub const unibi_enter_reverse_mode: c_int = 120; +pub const unibi_enter_standout_mode: c_int = 121; +pub const unibi_enter_underline_mode: c_int = 122; +pub const unibi_erase_chars: c_int = 123; +pub const unibi_exit_alt_charset_mode: c_int = 124; +pub const unibi_exit_attribute_mode: c_int = 125; +pub const unibi_exit_ca_mode: c_int = 126; +pub const unibi_exit_delete_mode: c_int = 127; +pub const unibi_exit_insert_mode: c_int = 128; +pub const unibi_exit_standout_mode: c_int = 129; +pub const unibi_exit_underline_mode: c_int = 130; +pub const unibi_flash_screen: c_int = 131; +pub const unibi_form_feed: c_int = 132; +pub const unibi_from_status_line: c_int = 133; +pub const unibi_init_1string: c_int = 134; +pub const unibi_init_2string: c_int = 135; +pub const unibi_init_3string: c_int = 136; +pub const unibi_init_file: c_int = 137; +pub const unibi_insert_character: c_int = 138; +pub const unibi_insert_line: c_int = 139; +pub const unibi_insert_padding: c_int = 140; +pub const unibi_key_backspace: c_int = 141; +pub const unibi_key_catab: c_int = 142; +pub const unibi_key_clear: c_int = 143; +pub const unibi_key_ctab: c_int = 144; +pub const unibi_key_dc: c_int = 145; +pub const unibi_key_dl: c_int = 146; +pub const unibi_key_down: c_int = 147; +pub const unibi_key_eic: c_int = 148; +pub const unibi_key_eol: c_int = 149; +pub const unibi_key_eos: c_int = 150; +pub const unibi_key_f0: c_int = 151; +pub const unibi_key_f1: c_int = 152; +pub const unibi_key_f10: c_int = 153; +pub const unibi_key_f2: c_int = 154; +pub const unibi_key_f3: c_int = 155; +pub const unibi_key_f4: c_int = 156; +pub const unibi_key_f5: c_int = 157; +pub const unibi_key_f6: c_int = 158; +pub const unibi_key_f7: c_int = 159; +pub const unibi_key_f8: c_int = 160; +pub const unibi_key_f9: c_int = 161; +pub const unibi_key_home: c_int = 162; +pub const unibi_key_ic: c_int = 163; +pub const unibi_key_il: c_int = 164; +pub const unibi_key_left: c_int = 165; +pub const unibi_key_ll: c_int = 166; +pub const unibi_key_npage: c_int = 167; +pub const unibi_key_ppage: c_int = 168; +pub const unibi_key_right: c_int = 169; +pub const unibi_key_sf: c_int = 170; +pub const unibi_key_sr: c_int = 171; +pub const unibi_key_stab: c_int = 172; +pub const unibi_key_up: c_int = 173; +pub const unibi_keypad_local: c_int = 174; +pub const unibi_keypad_xmit: c_int = 175; +pub const unibi_lab_f0: c_int = 176; +pub const unibi_lab_f1: c_int = 177; +pub const unibi_lab_f10: c_int = 178; +pub const unibi_lab_f2: c_int = 179; +pub const unibi_lab_f3: c_int = 180; +pub const unibi_lab_f4: c_int = 181; +pub const unibi_lab_f5: c_int = 182; +pub const unibi_lab_f6: c_int = 183; +pub const unibi_lab_f7: c_int = 184; +pub const unibi_lab_f8: c_int = 185; +pub const unibi_lab_f9: c_int = 186; +pub const unibi_meta_off: c_int = 187; +pub const unibi_meta_on: c_int = 188; +pub const unibi_newline: c_int = 189; +pub const unibi_pad_char: c_int = 190; +pub const unibi_parm_dch: c_int = 191; +pub const unibi_parm_delete_line: c_int = 192; +pub const unibi_parm_down_cursor: c_int = 193; +pub const unibi_parm_ich: c_int = 194; +pub const unibi_parm_index: c_int = 195; +pub const unibi_parm_insert_line: c_int = 196; +pub const unibi_parm_left_cursor: c_int = 197; +pub const unibi_parm_right_cursor: c_int = 198; +pub const unibi_parm_rindex: c_int = 199; +pub const unibi_parm_up_cursor: c_int = 200; +pub const unibi_pkey_key: c_int = 201; +pub const unibi_pkey_local: c_int = 202; +pub const unibi_pkey_xmit: c_int = 203; +pub const unibi_print_screen: c_int = 204; +pub const unibi_prtr_off: c_int = 205; +pub const unibi_prtr_on: c_int = 206; +pub const unibi_repeat_char: c_int = 207; +pub const unibi_reset_1string: c_int = 208; +pub const unibi_reset_2string: c_int = 209; +pub const unibi_reset_3string: c_int = 210; +pub const unibi_reset_file: c_int = 211; +pub const unibi_restore_cursor: c_int = 212; +pub const unibi_row_address: c_int = 213; +pub const unibi_save_cursor: c_int = 214; +pub const unibi_scroll_forward: c_int = 215; +pub const unibi_scroll_reverse: c_int = 216; +pub const unibi_set_attributes: c_int = 217; +pub const unibi_set_tab: c_int = 218; +pub const unibi_set_window: c_int = 219; +pub const unibi_tab: c_int = 220; +pub const unibi_to_status_line: c_int = 221; +pub const unibi_underline_char: c_int = 222; +pub const unibi_up_half_line: c_int = 223; +pub const unibi_init_prog: c_int = 224; +pub const unibi_key_a1: c_int = 225; +pub const unibi_key_a3: c_int = 226; +pub const unibi_key_b2: c_int = 227; +pub const unibi_key_c1: c_int = 228; +pub const unibi_key_c3: c_int = 229; +pub const unibi_prtr_non: c_int = 230; +pub const unibi_char_padding: c_int = 231; +pub const unibi_acs_chars: c_int = 232; +pub const unibi_plab_norm: c_int = 233; +pub const unibi_key_btab: c_int = 234; +pub const unibi_enter_xon_mode: c_int = 235; +pub const unibi_exit_xon_mode: c_int = 236; +pub const unibi_enter_am_mode: c_int = 237; +pub const unibi_exit_am_mode: c_int = 238; +pub const unibi_xon_character: c_int = 239; +pub const unibi_xoff_character: c_int = 240; +pub const unibi_ena_acs: c_int = 241; +pub const unibi_label_on: c_int = 242; +pub const unibi_label_off: c_int = 243; +pub const unibi_key_beg: c_int = 244; +pub const unibi_key_cancel: c_int = 245; +pub const unibi_key_close: c_int = 246; +pub const unibi_key_command: c_int = 247; +pub const unibi_key_copy: c_int = 248; +pub const unibi_key_create: c_int = 249; +pub const unibi_key_end: c_int = 250; +pub const unibi_key_enter: c_int = 251; +pub const unibi_key_exit: c_int = 252; +pub const unibi_key_find: c_int = 253; +pub const unibi_key_help: c_int = 254; +pub const unibi_key_mark: c_int = 255; +pub const unibi_key_message: c_int = 256; +pub const unibi_key_move: c_int = 257; +pub const unibi_key_next: c_int = 258; +pub const unibi_key_open: c_int = 259; +pub const unibi_key_options: c_int = 260; +pub const unibi_key_previous: c_int = 261; +pub const unibi_key_print: c_int = 262; +pub const unibi_key_redo: c_int = 263; +pub const unibi_key_reference: c_int = 264; +pub const unibi_key_refresh: c_int = 265; +pub const unibi_key_replace: c_int = 266; +pub const unibi_key_restart: c_int = 267; +pub const unibi_key_resume: c_int = 268; +pub const unibi_key_save: c_int = 269; +pub const unibi_key_suspend: c_int = 270; +pub const unibi_key_undo: c_int = 271; +pub const unibi_key_sbeg: c_int = 272; +pub const unibi_key_scancel: c_int = 273; +pub const unibi_key_scommand: c_int = 274; +pub const unibi_key_scopy: c_int = 275; +pub const unibi_key_screate: c_int = 276; +pub const unibi_key_sdc: c_int = 277; +pub const unibi_key_sdl: c_int = 278; +pub const unibi_key_select: c_int = 279; +pub const unibi_key_send: c_int = 280; +pub const unibi_key_seol: c_int = 281; +pub const unibi_key_sexit: c_int = 282; +pub const unibi_key_sfind: c_int = 283; +pub const unibi_key_shelp: c_int = 284; +pub const unibi_key_shome: c_int = 285; +pub const unibi_key_sic: c_int = 286; +pub const unibi_key_sleft: c_int = 287; +pub const unibi_key_smessage: c_int = 288; +pub const unibi_key_smove: c_int = 289; +pub const unibi_key_snext: c_int = 290; +pub const unibi_key_soptions: c_int = 291; +pub const unibi_key_sprevious: c_int = 292; +pub const unibi_key_sprint: c_int = 293; +pub const unibi_key_sredo: c_int = 294; +pub const unibi_key_sreplace: c_int = 295; +pub const unibi_key_sright: c_int = 296; +pub const unibi_key_srsume: c_int = 297; +pub const unibi_key_ssave: c_int = 298; +pub const unibi_key_ssuspend: c_int = 299; +pub const unibi_key_sundo: c_int = 300; +pub const unibi_req_for_input: c_int = 301; +pub const unibi_key_f11: c_int = 302; +pub const unibi_key_f12: c_int = 303; +pub const unibi_key_f13: c_int = 304; +pub const unibi_key_f14: c_int = 305; +pub const unibi_key_f15: c_int = 306; +pub const unibi_key_f16: c_int = 307; +pub const unibi_key_f17: c_int = 308; +pub const unibi_key_f18: c_int = 309; +pub const unibi_key_f19: c_int = 310; +pub const unibi_key_f20: c_int = 311; +pub const unibi_key_f21: c_int = 312; +pub const unibi_key_f22: c_int = 313; +pub const unibi_key_f23: c_int = 314; +pub const unibi_key_f24: c_int = 315; +pub const unibi_key_f25: c_int = 316; +pub const unibi_key_f26: c_int = 317; +pub const unibi_key_f27: c_int = 318; +pub const unibi_key_f28: c_int = 319; +pub const unibi_key_f29: c_int = 320; +pub const unibi_key_f30: c_int = 321; +pub const unibi_key_f31: c_int = 322; +pub const unibi_key_f32: c_int = 323; +pub const unibi_key_f33: c_int = 324; +pub const unibi_key_f34: c_int = 325; +pub const unibi_key_f35: c_int = 326; +pub const unibi_key_f36: c_int = 327; +pub const unibi_key_f37: c_int = 328; +pub const unibi_key_f38: c_int = 329; +pub const unibi_key_f39: c_int = 330; +pub const unibi_key_f40: c_int = 331; +pub const unibi_key_f41: c_int = 332; +pub const unibi_key_f42: c_int = 333; +pub const unibi_key_f43: c_int = 334; +pub const unibi_key_f44: c_int = 335; +pub const unibi_key_f45: c_int = 336; +pub const unibi_key_f46: c_int = 337; +pub const unibi_key_f47: c_int = 338; +pub const unibi_key_f48: c_int = 339; +pub const unibi_key_f49: c_int = 340; +pub const unibi_key_f50: c_int = 341; +pub const unibi_key_f51: c_int = 342; +pub const unibi_key_f52: c_int = 343; +pub const unibi_key_f53: c_int = 344; +pub const unibi_key_f54: c_int = 345; +pub const unibi_key_f55: c_int = 346; +pub const unibi_key_f56: c_int = 347; +pub const unibi_key_f57: c_int = 348; +pub const unibi_key_f58: c_int = 349; +pub const unibi_key_f59: c_int = 350; +pub const unibi_key_f60: c_int = 351; +pub const unibi_key_f61: c_int = 352; +pub const unibi_key_f62: c_int = 353; +pub const unibi_key_f63: c_int = 354; +pub const unibi_clr_bol: c_int = 355; +pub const unibi_clear_margins: c_int = 356; +pub const unibi_set_left_margin: c_int = 357; +pub const unibi_set_right_margin: c_int = 358; +pub const unibi_label_format: c_int = 359; +pub const unibi_set_clock: c_int = 360; +pub const unibi_display_clock: c_int = 361; +pub const unibi_remove_clock: c_int = 362; +pub const unibi_create_window: c_int = 363; +pub const unibi_goto_window: c_int = 364; +pub const unibi_hangup: c_int = 365; +pub const unibi_dial_phone: c_int = 366; +pub const unibi_quick_dial: c_int = 367; +pub const unibi_tone: c_int = 368; +pub const unibi_pulse: c_int = 369; +pub const unibi_flash_hook: c_int = 370; +pub const unibi_fixed_pause: c_int = 371; +pub const unibi_wait_tone: c_int = 372; +pub const unibi_user0: c_int = 373; +pub const unibi_user1: c_int = 374; +pub const unibi_user2: c_int = 375; +pub const unibi_user3: c_int = 376; +pub const unibi_user4: c_int = 377; +pub const unibi_user5: c_int = 378; +pub const unibi_user6: c_int = 379; +pub const unibi_user7: c_int = 380; +pub const unibi_user8: c_int = 381; +pub const unibi_user9: c_int = 382; +pub const unibi_orig_pair: c_int = 383; +pub const unibi_orig_colors: c_int = 384; +pub const unibi_initialize_color: c_int = 385; +pub const unibi_initialize_pair: c_int = 386; +pub const unibi_set_color_pair: c_int = 387; +pub const unibi_set_foreground: c_int = 388; +pub const unibi_set_background: c_int = 389; +pub const unibi_change_char_pitch: c_int = 390; +pub const unibi_change_line_pitch: c_int = 391; +pub const unibi_change_res_horz: c_int = 392; +pub const unibi_change_res_vert: c_int = 393; +pub const unibi_define_char: c_int = 394; +pub const unibi_enter_doublewide_mode: c_int = 395; +pub const unibi_enter_draft_quality: c_int = 396; +pub const unibi_enter_italics_mode: c_int = 397; +pub const unibi_enter_leftward_mode: c_int = 398; +pub const unibi_enter_micro_mode: c_int = 399; +pub const unibi_enter_near_letter_quality: c_int = 400; +pub const unibi_enter_normal_quality: c_int = 401; +pub const unibi_enter_shadow_mode: c_int = 402; +pub const unibi_enter_subscript_mode: c_int = 403; +pub const unibi_enter_superscript_mode: c_int = 404; +pub const unibi_enter_upward_mode: c_int = 405; +pub const unibi_exit_doublewide_mode: c_int = 406; +pub const unibi_exit_italics_mode: c_int = 407; +pub const unibi_exit_leftward_mode: c_int = 408; +pub const unibi_exit_micro_mode: c_int = 409; +pub const unibi_exit_shadow_mode: c_int = 410; +pub const unibi_exit_subscript_mode: c_int = 411; +pub const unibi_exit_superscript_mode: c_int = 412; +pub const unibi_exit_upward_mode: c_int = 413; +pub const unibi_micro_column_address: c_int = 414; +pub const unibi_micro_down: c_int = 415; +pub const unibi_micro_left: c_int = 416; +pub const unibi_micro_right: c_int = 417; +pub const unibi_micro_row_address: c_int = 418; +pub const unibi_micro_up: c_int = 419; +pub const unibi_order_of_pins: c_int = 420; +pub const unibi_parm_down_micro: c_int = 421; +pub const unibi_parm_left_micro: c_int = 422; +pub const unibi_parm_right_micro: c_int = 423; +pub const unibi_parm_up_micro: c_int = 424; +pub const unibi_select_char_set: c_int = 425; +pub const unibi_set_bottom_margin: c_int = 426; +pub const unibi_set_bottom_margin_parm: c_int = 427; +pub const unibi_set_left_margin_parm: c_int = 428; +pub const unibi_set_right_margin_parm: c_int = 429; +pub const unibi_set_top_margin: c_int = 430; +pub const unibi_set_top_margin_parm: c_int = 431; +pub const unibi_start_bit_image: c_int = 432; +pub const unibi_start_char_set_def: c_int = 433; +pub const unibi_stop_bit_image: c_int = 434; +pub const unibi_stop_char_set_def: c_int = 435; +pub const unibi_subscript_characters: c_int = 436; +pub const unibi_superscript_characters: c_int = 437; +pub const unibi_these_cause_cr: c_int = 438; +pub const unibi_zero_motion: c_int = 439; +pub const unibi_char_set_names: c_int = 440; +pub const unibi_key_mouse: c_int = 441; +pub const unibi_mouse_info: c_int = 442; +pub const unibi_req_mouse_pos: c_int = 443; +pub const unibi_get_mouse: c_int = 444; +pub const unibi_set_a_foreground: c_int = 445; +pub const unibi_set_a_background: c_int = 446; +pub const unibi_pkey_plab: c_int = 447; +pub const unibi_device_type: c_int = 448; +pub const unibi_code_set_init: c_int = 449; +pub const unibi_set0_des_seq: c_int = 450; +pub const unibi_set1_des_seq: c_int = 451; +pub const unibi_set2_des_seq: c_int = 452; +pub const unibi_set3_des_seq: c_int = 453; +pub const unibi_set_lr_margin: c_int = 454; +pub const unibi_set_tb_margin: c_int = 455; +pub const unibi_bit_image_repeat: c_int = 456; +pub const unibi_bit_image_newline: c_int = 457; +pub const unibi_bit_image_carriage_return: c_int = 458; +pub const unibi_color_names: c_int = 459; +pub const unibi_define_bit_image_region: c_int = 460; +pub const unibi_end_bit_image_region: c_int = 461; +pub const unibi_set_color_band: c_int = 462; +pub const unibi_set_page_length: c_int = 463; +pub const unibi_display_pc_char: c_int = 464; +pub const unibi_enter_pc_charset_mode: c_int = 465; +pub const unibi_exit_pc_charset_mode: c_int = 466; +pub const unibi_enter_scancode_mode: c_int = 467; +pub const unibi_exit_scancode_mode: c_int = 468; +pub const unibi_pc_term_options: c_int = 469; +pub const unibi_scancode_escape: c_int = 470; +pub const unibi_alt_scancode_esc: c_int = 471; +pub const unibi_enter_horizontal_hl_mode: c_int = 472; +pub const unibi_enter_left_hl_mode: c_int = 473; +pub const unibi_enter_low_hl_mode: c_int = 474; +pub const unibi_enter_right_hl_mode: c_int = 475; +pub const unibi_enter_top_hl_mode: c_int = 476; +pub const unibi_enter_vertical_hl_mode: c_int = 477; +pub const unibi_set_a_attributes: c_int = 478; +pub const unibi_set_pglen_inch: c_int = 479; +pub const unibi_termcap_init2: c_int = 480; +pub const unibi_termcap_reset: c_int = 481; +pub const unibi_linefeed_if_not_lf: c_int = 482; +pub const unibi_backspace_if_not_bs: c_int = 483; +pub const unibi_other_non_function_keys: c_int = 484; +pub const unibi_arrow_key_map: c_int = 485; +pub const unibi_acs_ulcorner: c_int = 486; +pub const unibi_acs_llcorner: c_int = 487; +pub const unibi_acs_urcorner: c_int = 488; +pub const unibi_acs_lrcorner: c_int = 489; +pub const unibi_acs_ltee: c_int = 490; +pub const unibi_acs_rtee: c_int = 491; +pub const unibi_acs_btee: c_int = 492; +pub const unibi_acs_ttee: c_int = 493; +pub const unibi_acs_hline: c_int = 494; +pub const unibi_acs_vline: c_int = 495; +pub const unibi_acs_plus: c_int = 496; +pub const unibi_memory_lock: c_int = 497; +pub const unibi_memory_unlock: c_int = 498; +pub const unibi_box_chars_1: c_int = 499; +pub const unibi_string_end_: c_int = 500; +pub const enum_unibi_string = c_uint; +pub const struct_unibi_term = opaque {}; +pub const unibi_term = struct_unibi_term; +pub extern fn unibi_dummy() ?*unibi_term; +pub extern fn unibi_from_mem([*c]const u8, usize) ?*unibi_term; +pub extern fn unibi_destroy(?*unibi_term) void; +pub extern fn unibi_dump(?*const unibi_term, [*c]u8, usize) usize; +pub extern fn unibi_get_name(?*const unibi_term) [*c]const u8; +pub extern fn unibi_set_name(?*unibi_term, [*c]const u8) void; +pub extern fn unibi_get_aliases(?*const unibi_term) [*c][*c]const u8; +pub extern fn unibi_set_aliases(?*unibi_term, [*c][*c]const u8) void; +pub extern fn unibi_get_bool(?*const unibi_term, enum_unibi_boolean) c_int; +pub extern fn unibi_set_bool(?*unibi_term, enum_unibi_boolean, c_int) void; +pub extern fn unibi_get_num(?*const unibi_term, enum_unibi_numeric) c_int; +pub extern fn unibi_set_num(?*unibi_term, enum_unibi_numeric, c_int) void; +pub extern fn unibi_get_str(?*const unibi_term, enum_unibi_string) [*c]const u8; +pub extern fn unibi_set_str(?*unibi_term, enum_unibi_string, [*c]const u8) void; +pub extern fn unibi_from_fp([*c]FILE) ?*unibi_term; +pub extern fn unibi_from_fd(c_int) ?*unibi_term; +pub extern fn unibi_from_file([*c]const u8) ?*unibi_term; +pub extern fn unibi_from_term([*c]const u8) ?*unibi_term; +pub extern fn unibi_from_env() ?*unibi_term; +pub extern const unibi_terminfo_dirs: [*c]const u8; +pub extern fn unibi_name_bool(enum_unibi_boolean) [*c]const u8; +pub extern fn unibi_short_name_bool(enum_unibi_boolean) [*c]const u8; +pub extern fn unibi_name_num(enum_unibi_numeric) [*c]const u8; +pub extern fn unibi_short_name_num(enum_unibi_numeric) [*c]const u8; +pub extern fn unibi_name_str(enum_unibi_string) [*c]const u8; +pub extern fn unibi_short_name_str(enum_unibi_string) [*c]const u8; +pub extern fn unibi_count_ext_bool(?*const unibi_term) usize; +pub extern fn unibi_count_ext_num(?*const unibi_term) usize; +pub extern fn unibi_count_ext_str(?*const unibi_term) usize; +pub extern fn unibi_get_ext_bool(?*const unibi_term, usize) c_int; +pub extern fn unibi_get_ext_num(?*const unibi_term, usize) c_int; +pub extern fn unibi_get_ext_str(?*const unibi_term, usize) [*c]const u8; +pub extern fn unibi_set_ext_bool(?*unibi_term, usize, c_int) void; +pub extern fn unibi_set_ext_num(?*unibi_term, usize, c_int) void; +pub extern fn unibi_set_ext_str(?*unibi_term, usize, [*c]const u8) void; +pub extern fn unibi_get_ext_bool_name(?*const unibi_term, usize) [*c]const u8; +pub extern fn unibi_get_ext_num_name(?*const unibi_term, usize) [*c]const u8; +pub extern fn unibi_get_ext_str_name(?*const unibi_term, usize) [*c]const u8; +pub extern fn unibi_set_ext_bool_name(?*unibi_term, usize, [*c]const u8) void; +pub extern fn unibi_set_ext_num_name(?*unibi_term, usize, [*c]const u8) void; +pub extern fn unibi_set_ext_str_name(?*unibi_term, usize, [*c]const u8) void; +pub extern fn unibi_add_ext_bool(?*unibi_term, [*c]const u8, c_int) usize; +pub extern fn unibi_add_ext_num(?*unibi_term, [*c]const u8, c_int) usize; +pub extern fn unibi_add_ext_str(?*unibi_term, [*c]const u8, [*c]const u8) usize; +pub extern fn unibi_del_ext_bool(?*unibi_term, usize) void; +pub extern fn unibi_del_ext_num(?*unibi_term, usize) void; +pub extern fn unibi_del_ext_str(?*unibi_term, usize) void; +pub const unibi_var_t = extern struct { + i_: c_int, + p_: [*c]u8, +}; +pub extern fn unibi_var_from_num(c_int) unibi_var_t; +pub extern fn unibi_var_from_str([*c]u8) unibi_var_t; +pub extern fn unibi_num_from_var(unibi_var_t) c_int; +pub extern fn unibi_str_from_var(unibi_var_t) [*c]const u8; +pub extern fn unibi_format([*c]unibi_var_t, [*c]unibi_var_t, [*c]const u8, [*c]unibi_var_t, ?*const fn (?*anyopaque, [*c]const u8, usize) callconv(.C) void, ?*anyopaque, ?*const fn (?*anyopaque, usize, c_int, c_int) callconv(.C) void, ?*anyopaque) void; +pub extern fn unibi_run([*c]const u8, [*c]unibi_var_t, [*c]u8, usize) usize; +pub extern fn terminfo_is_term_family(term: [*c]const u8, family: [*c]const u8) bool; +pub extern fn terminfo_is_bsd_console(term: [*c]const u8) bool; +pub extern fn terminfo_from_builtin(term: [*c]const u8, termname: [*c][*c]u8) ?*unibi_term; +pub extern fn terminfo_info_msg(ut: ?*const unibi_term, termname: [*c]const u8) String; +pub const ansi_terminfo: [1481]i8 = [1481]i8{ + 26, + 1, + 40, + 0, + 38, + 0, + 16, + 0, + 125, + 1, + 68, + 2, + 97, + 110, + 115, + 105, + 124, + 97, + 110, + 115, + 105, + 47, + 112, + 99, + 45, + 116, + 101, + 114, + 109, + 32, + 99, + 111, + 109, + 112, + 97, + 116, + 105, + 98, + 108, + 101, + 32, + 119, + 105, + 116, + 104, + 32, + 99, + 111, + 108, + 111, + 114, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 80, + 0, + 8, + 0, + 24, + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 8, + 0, + 64, + 0, + 3, + 0, + 0, + 0, + 4, + 0, + 6, + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 8, + 0, + 13, + 0, + 20, + 0, + 24, + 0, + 28, + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 39, + 0, + 56, + 0, + 60, + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 64, + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 68, + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 72, + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 76, + 0, + 80, + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 84, + 0, + 90, + 0, + 95, + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 100, + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 105, + 0, + 110, + 0, + 115, + 0, + 120, + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 127))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 121))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 113))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 109))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 105))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 101))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 99))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 95))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 91))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 87))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 83))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 79))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 75))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 70))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 61))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 52))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 43))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 34))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 25))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 16))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 7))), + 0, + 2, + 1, + 11, + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 20, + 1, + 25, + 1, + 30, + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 50, + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 61, + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 63, + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 107))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 104))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 100))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 37))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 33))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 28))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 17))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 12))), + 1, + 7, + 2, + 11, + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 20, + 2, + 30, + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 40, + 2, + 44, + 2, + 48, + 2, + 52, + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 56, + 2, + 62, + 2, + 27, + 91, + 90, + 0, + 7, + 0, + 13, + 0, + 27, + 91, + 51, + 103, + 0, + 27, + 91, + 72, + 27, + 91, + 74, + 0, + 27, + 91, + 75, + 0, + 27, + 91, + 74, + 0, + 27, + 91, + 37, + 105, + 37, + 112, + 49, + 37, + 100, + 71, + 0, + 27, + 91, + 37, + 105, + 37, + 112, + 49, + 37, + 100, + 59, + 37, + 112, + 50, + 37, + 100, + 72, + 0, + 27, + 91, + 66, + 0, + 27, + 91, + 72, + 0, + 27, + 91, + 68, + 0, + 27, + 91, + 67, + 0, + 27, + 91, + 65, + 0, + 27, + 91, + 80, + 0, + 27, + 91, + 77, + 0, + 27, + 91, + 49, + 49, + 109, + 0, + 27, + 91, + 53, + 109, + 0, + 27, + 91, + 49, + 109, + 0, + 27, + 91, + 56, + 109, + 0, + 27, + 91, + 55, + 109, + 0, + 27, + 91, + 55, + 109, + 0, + 27, + 91, + 52, + 109, + 0, + 27, + 91, + 37, + 112, + 49, + 37, + 100, + 88, + 0, + 27, + 91, + 49, + 48, + 109, + 0, + 27, + 91, + 48, + 59, + 49, + 48, + 109, + 0, + 27, + 91, + 109, + 0, + 27, + 91, + 109, + 0, + 27, + 91, + 76, + 0, + 8, + 0, + 27, + 91, + 66, + 0, + 27, + 91, + 72, + 0, + 27, + 91, + 76, + 0, + 27, + 91, + 68, + 0, + 27, + 91, + 67, + 0, + 27, + 91, + 65, + 0, + 13, + 27, + 91, + 83, + 0, + 27, + 91, + 37, + 112, + 49, + 37, + 100, + 80, + 0, + 27, + 91, + 37, + 112, + 49, + 37, + 100, + 77, + 0, + 27, + 91, + 37, + 112, + 49, + 37, + 100, + 66, + 0, + 27, + 91, + 37, + 112, + 49, + 37, + 100, + 64, + 0, + 27, + 91, + 37, + 112, + 49, + 37, + 100, + 83, + 0, + 27, + 91, + 37, + 112, + 49, + 37, + 100, + 76, + 0, + 27, + 91, + 37, + 112, + 49, + 37, + 100, + 68, + 0, + 27, + 91, + 37, + 112, + 49, + 37, + 100, + 67, + 0, + 27, + 91, + 37, + 112, + 49, + 37, + 100, + 84, + 0, + 27, + 91, + 37, + 112, + 49, + 37, + 100, + 65, + 0, + 27, + 91, + 52, + 105, + 0, + 27, + 91, + 53, + 105, + 0, + 37, + 112, + 49, + 37, + 99, + 27, + 91, + 37, + 112, + 50, + 37, + 123, + 49, + 125, + 37, + 45, + 37, + 100, + 98, + 0, + 27, + 91, + 37, + 105, + 37, + 112, + 49, + 37, + 100, + 100, + 0, + 10, + 0, + 27, + 91, + 48, + 59, + 49, + 48, + 37, + 63, + 37, + 112, + 49, + 37, + 116, + 59, + 55, + 37, + 59, + 37, + 63, + 37, + 112, + 50, + 37, + 116, + 59, + 52, + 37, + 59, + 37, + 63, + 37, + 112, + 51, + 37, + 116, + 59, + 55, + 37, + 59, + 37, + 63, + 37, + 112, + 52, + 37, + 116, + 59, + 53, + 37, + 59, + 37, + 63, + 37, + 112, + 54, + 37, + 116, + 59, + 49, + 37, + 59, + 37, + 63, + 37, + 112, + 55, + 37, + 116, + 59, + 56, + 37, + 59, + 37, + 63, + 37, + 112, + 57, + 37, + 116, + 59, + 49, + 49, + 37, + 59, + 109, + 0, + 27, + 72, + 0, + 27, + 91, + 73, + 0, + 43, + 16, + 44, + 17, + 45, + 24, + 46, + 25, + 48, + @bitCast(i8, @truncate(i8, -@as(c_int, 37))), + 96, + 4, + 97, + @bitCast(i8, @truncate(i8, -@as(c_int, 79))), + 102, + @bitCast(i8, @truncate(i8, -@as(c_int, 8))), + 103, + @bitCast(i8, @truncate(i8, -@as(c_int, 15))), + 104, + @bitCast(i8, @truncate(i8, -@as(c_int, 80))), + 106, + @bitCast(i8, @truncate(i8, -@as(c_int, 39))), + 107, + @bitCast(i8, @truncate(i8, -@as(c_int, 65))), + 108, + @bitCast(i8, @truncate(i8, -@as(c_int, 38))), + 109, + @bitCast(i8, @truncate(i8, -@as(c_int, 64))), + 110, + @bitCast(i8, @truncate(i8, -@as(c_int, 59))), + 111, + 126, + 112, + @bitCast(i8, @truncate(i8, -@as(c_int, 60))), + 113, + @bitCast(i8, @truncate(i8, -@as(c_int, 60))), + 114, + @bitCast(i8, @truncate(i8, -@as(c_int, 60))), + 115, + 95, + 116, + @bitCast(i8, @truncate(i8, -@as(c_int, 61))), + 117, + @bitCast(i8, @truncate(i8, -@as(c_int, 76))), + 118, + @bitCast(i8, @truncate(i8, -@as(c_int, 63))), + 119, + @bitCast(i8, @truncate(i8, -@as(c_int, 62))), + 120, + @bitCast(i8, @truncate(i8, -@as(c_int, 77))), + 121, + @bitCast(i8, @truncate(i8, -@as(c_int, 13))), + 122, + @bitCast(i8, @truncate(i8, -@as(c_int, 14))), + 123, + @bitCast(i8, @truncate(i8, -@as(c_int, 29))), + 124, + @bitCast(i8, @truncate(i8, -@as(c_int, 40))), + 125, + @bitCast(i8, @truncate(i8, -@as(c_int, 100))), + 126, + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + 0, + 27, + 91, + 90, + 0, + 27, + 91, + 49, + 75, + 0, + 27, + 91, + 37, + 105, + 37, + 100, + 59, + 37, + 100, + 82, + 0, + 27, + 91, + 54, + 110, + 0, + 27, + 91, + 63, + 37, + 91, + 59, + 48, + 49, + 50, + 51, + 52, + 53, + 54, + 55, + 56, + 57, + 93, + 99, + 0, + 27, + 91, + 99, + 0, + 27, + 91, + 51, + 57, + 59, + 52, + 57, + 109, + 0, + 27, + 91, + 51, + 37, + 112, + 49, + 37, + 100, + 109, + 0, + 27, + 91, + 52, + 37, + 112, + 49, + 37, + 100, + 109, + 0, + 27, + 40, + 66, + 0, + 27, + 41, + 66, + 0, + 27, + 42, + 66, + 0, + 27, + 43, + 66, + 0, + 27, + 91, + 49, + 49, + 109, + 0, + 27, + 91, + 49, + 48, + 109, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 3, + 0, + 1, + 0, + 0, + 0, + 65, + 88, + 0, +}; +pub const conemu_terminfo: [2602]i8 = [2602]i8{ + 30, + 2, + 61, + 0, + 38, + 0, + 15, + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 99))), + 1, + 57, + 3, + 99, + 111, + 110, + 101, + 109, + 117, + 124, + 65, + 78, + 73, + 83, + 32, + 88, + 51, + 46, + 54, + 52, + 32, + 97, + 110, + 100, + 32, + 88, + 116, + 101, + 114, + 109, + 32, + 50, + 53, + 54, + 32, + 99, + 111, + 108, + 111, + 114, + 115, + 32, + 102, + 111, + 114, + 32, + 67, + 111, + 110, + 69, + 109, + 117, + 32, + 119, + 105, + 116, + 104, + 32, + 108, + 105, + 98, + 117, + 118, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 80, + 0, + 0, + 0, + 8, + 0, + 0, + 0, + 24, + 0, + 0, + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 0, + 1, + 0, + 0, + 0, + 0, + 1, + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 0, + 0, + 2, + 0, + 4, + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 21, + 0, + 29, + 0, + 33, + 0, + 37, + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 48, + 0, + 65, + 0, + 69, + 0, + 73, + 0, + 80, + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 82, + 0, + 89, + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 93, + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 97, + 0, + 101, + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 105, + 0, + 110, + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 119, + 0, + 124, + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 127))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 122))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 113))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 108))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 99))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 93))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 87))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 83))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 81))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 76))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 72))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 67))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 61))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 56))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 51))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 46))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 41))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 35))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 29))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 23))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 17))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 12))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 7))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 3))), + 0, + 2, + 1, + 7, + 1, + 11, + 1, + 18, + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 25, + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 29, + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 32, + 1, + 41, + 1, + 50, + 1, + 59, + 1, + 68, + 1, + 77, + 1, + 86, + 1, + 95, + 1, + 104, + 1, + 113, + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 122, + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 114))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 111))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 100))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 97))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 95))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 92))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 49))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 47))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 43))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 39))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 35))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 31))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 27))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 23))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 18))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 14))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 7))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 0, + 2, + 7, + 2, + 14, + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 21, + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 28, + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 35, + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 42, + 2, + 48, + 2, + 54, + 2, + 60, + 2, + 66, + 2, + 72, + 2, + 78, + 2, + 84, + 2, + 90, + 2, + 96, + 2, + 102, + 2, + 108, + 2, + 114, + 2, + 120, + 2, + 126, + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 124))), + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 118))), + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 112))), + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 106))), + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 100))), + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 94))), + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 88))), + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 82))), + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 76))), + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 70))), + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 64))), + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 58))), + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 52))), + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 46))), + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 40))), + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 33))), + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 27))), + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 21))), + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 15))), + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 9))), + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 3))), + 2, + 2, + 3, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 9, + 3, + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 18, + 3, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 23, + 3, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 29, + 3, + 43, + 3, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 7, + 0, + 13, + 0, + 27, + 91, + 37, + 105, + 37, + 112, + 49, + 37, + 100, + 59, + 37, + 112, + 50, + 37, + 100, + 114, + 0, + 27, + 91, + 72, + 27, + 91, + 50, + 74, + 0, + 27, + 91, + 75, + 0, + 27, + 91, + 74, + 0, + 27, + 91, + 37, + 105, + 37, + 112, + 49, + 37, + 100, + 71, + 0, + 27, + 91, + 37, + 105, + 37, + 112, + 49, + 37, + 100, + 59, + 37, + 112, + 50, + 37, + 100, + 72, + 0, + 27, + 91, + 66, + 0, + 27, + 91, + 72, + 0, + 27, + 91, + 63, + 50, + 53, + 108, + 0, + 8, + 0, + 27, + 91, + 63, + 50, + 53, + 104, + 0, + 27, + 91, + 67, + 0, + 27, + 91, + 65, + 0, + 27, + 91, + 80, + 0, + 27, + 91, + 77, + 0, + 27, + 91, + 49, + 109, + 0, + 27, + 91, + 63, + 49, + 48, + 52, + 57, + 104, + 0, + 27, + 91, + 55, + 109, + 0, + 27, + 91, + 55, + 109, + 0, + 27, + 91, + 52, + 109, + 0, + 27, + 91, + 37, + 112, + 49, + 37, + 100, + 88, + 0, + 27, + 91, + 48, + 109, + 0, + 27, + 91, + 63, + 49, + 48, + 52, + 57, + 108, + 0, + 27, + 91, + 50, + 55, + 109, + 0, + 27, + 91, + 50, + 52, + 109, + 0, + 27, + 91, + 76, + 0, + 8, + 0, + 27, + 91, + 51, + 126, + 0, + 27, + 91, + 66, + 0, + 27, + 91, + 91, + 65, + 0, + 27, + 91, + 50, + 49, + 126, + 0, + 27, + 91, + 91, + 66, + 0, + 27, + 91, + 91, + 67, + 0, + 27, + 91, + 91, + 68, + 0, + 27, + 91, + 91, + 69, + 0, + 27, + 91, + 49, + 55, + 126, + 0, + 27, + 91, + 49, + 56, + 126, + 0, + 27, + 91, + 49, + 57, + 126, + 0, + 27, + 91, + 50, + 48, + 126, + 0, + 27, + 91, + 49, + 126, + 0, + 27, + 91, + 50, + 126, + 0, + 27, + 91, + 68, + 0, + 27, + 91, + 54, + 126, + 0, + 27, + 91, + 53, + 126, + 0, + 27, + 91, + 67, + 0, + 27, + 91, + 49, + 59, + 50, + 66, + 0, + 27, + 91, + 49, + 59, + 50, + 65, + 0, + 27, + 91, + 65, + 0, + 27, + 69, + 0, + 27, + 91, + 37, + 112, + 49, + 37, + 100, + 80, + 0, + 27, + 91, + 37, + 112, + 49, + 37, + 100, + 77, + 0, + 27, + 91, + 37, + 112, + 49, + 37, + 100, + 66, + 0, + 27, + 91, + 37, + 112, + 49, + 37, + 100, + 64, + 0, + 27, + 91, + 37, + 112, + 49, + 37, + 100, + 83, + 0, + 27, + 91, + 37, + 112, + 49, + 37, + 100, + 76, + 0, + 27, + 91, + 37, + 112, + 49, + 37, + 100, + 68, + 0, + 27, + 91, + 37, + 112, + 49, + 37, + 100, + 67, + 0, + 27, + 91, + 37, + 112, + 49, + 37, + 100, + 84, + 0, + 27, + 91, + 37, + 112, + 49, + 37, + 100, + 65, + 0, + 37, + 112, + 49, + 37, + 99, + 27, + 91, + 37, + 112, + 50, + 37, + 123, + 49, + 125, + 37, + 45, + 37, + 100, + 98, + 0, + 27, + 56, + 0, + 27, + 91, + 37, + 105, + 37, + 112, + 49, + 37, + 100, + 100, + 0, + 27, + 55, + 0, + 10, + 0, + 27, + 77, + 0, + 27, + 91, + 48, + 37, + 63, + 37, + 112, + 49, + 37, + 112, + 51, + 37, + 124, + 37, + 116, + 59, + 55, + 37, + 59, + 37, + 63, + 37, + 112, + 50, + 37, + 116, + 59, + 52, + 37, + 59, + 37, + 63, + 37, + 112, + 54, + 37, + 116, + 59, + 49, + 37, + 59, + 109, + 0, + 9, + 0, + 27, + 79, + 119, + 0, + 27, + 79, + 121, + 0, + 27, + 91, + 71, + 0, + 27, + 79, + 113, + 0, + 27, + 79, + 115, + 0, + 27, + 91, + 90, + 0, + 27, + 91, + 52, + 126, + 0, + 27, + 79, + 77, + 0, + 27, + 91, + 51, + 59, + 50, + 126, + 0, + 27, + 91, + 52, + 59, + 50, + 126, + 0, + 27, + 91, + 49, + 59, + 50, + 126, + 0, + 27, + 91, + 50, + 59, + 50, + 126, + 0, + 27, + 91, + 49, + 59, + 50, + 68, + 0, + 27, + 91, + 54, + 59, + 50, + 126, + 0, + 27, + 91, + 53, + 59, + 50, + 126, + 0, + 27, + 91, + 49, + 59, + 50, + 67, + 0, + 27, + 91, + 50, + 51, + 126, + 0, + 27, + 91, + 50, + 52, + 126, + 0, + 27, + 91, + 50, + 53, + 126, + 0, + 27, + 91, + 50, + 54, + 126, + 0, + 27, + 91, + 50, + 56, + 126, + 0, + 27, + 91, + 50, + 57, + 126, + 0, + 27, + 91, + 51, + 49, + 126, + 0, + 27, + 91, + 51, + 50, + 126, + 0, + 27, + 91, + 51, + 51, + 126, + 0, + 27, + 91, + 51, + 52, + 126, + 0, + 27, + 91, + 50, + 51, + 36, + 0, + 27, + 91, + 50, + 52, + 36, + 0, + 27, + 91, + 49, + 49, + 94, + 0, + 27, + 91, + 49, + 50, + 94, + 0, + 27, + 91, + 49, + 51, + 94, + 0, + 27, + 91, + 49, + 52, + 94, + 0, + 27, + 91, + 49, + 53, + 94, + 0, + 27, + 91, + 49, + 55, + 94, + 0, + 27, + 91, + 49, + 56, + 94, + 0, + 27, + 91, + 49, + 57, + 94, + 0, + 27, + 91, + 50, + 48, + 94, + 0, + 27, + 91, + 50, + 49, + 94, + 0, + 27, + 91, + 50, + 51, + 94, + 0, + 27, + 91, + 50, + 52, + 94, + 0, + 27, + 91, + 50, + 53, + 94, + 0, + 27, + 91, + 50, + 54, + 94, + 0, + 27, + 91, + 50, + 56, + 94, + 0, + 27, + 91, + 50, + 57, + 94, + 0, + 27, + 91, + 51, + 49, + 94, + 0, + 27, + 91, + 49, + 59, + 54, + 83, + 0, + 27, + 91, + 51, + 50, + 94, + 0, + 27, + 91, + 51, + 51, + 94, + 0, + 27, + 91, + 51, + 52, + 94, + 0, + 27, + 91, + 50, + 51, + 64, + 0, + 27, + 91, + 50, + 52, + 64, + 0, + 27, + 91, + 49, + 75, + 0, + 27, + 91, + 63, + 54, + 57, + 108, + 0, + 27, + 91, + 51, + 57, + 59, + 52, + 57, + 109, + 0, + 27, + 91, + 51, + 109, + 0, + 27, + 91, + 50, + 51, + 109, + 0, + 27, + 91, + 51, + 56, + 59, + 53, + 59, + 37, + 112, + 49, + 37, + 100, + 109, + 0, + 27, + 91, + 52, + 56, + 59, + 53, + 59, + 37, + 112, + 49, + 37, + 100, + 109, + 0, + 0, + 2, + 0, + 0, + 0, + 74, + 0, + 92, + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 46))), + 1, + 1, + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 0, + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 5, + 0, + 11, + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 21, + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 28, + 0, + 32, + 0, + 36, + 0, + 40, + 0, + 44, + 0, + 48, + 0, + 52, + 0, + 56, + 0, + 60, + 0, + 64, + 0, + 68, + 0, + 72, + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 0, + 0, + 3, + 0, + 6, + 0, + 9, + 0, + 12, + 0, + 15, + 0, + 18, + 0, + 21, + 0, + 24, + 0, + 27, + 0, + 32, + 0, + 37, + 0, + 42, + 0, + 47, + 0, + 52, + 0, + 56, + 0, + 61, + 0, + 66, + 0, + 71, + 0, + 76, + 0, + 81, + 0, + 87, + 0, + 93, + 0, + 99, + 0, + 105, + 0, + 111, + 0, + 117, + 0, + 123, + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 127))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 121))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 115))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 110))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 105))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 100))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 95))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 90))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 84))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 78))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 72))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 66))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 60))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 54))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 48))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 42))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 36))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 30))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 24))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 18))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 12))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 6))), + 0, + 0, + 1, + 6, + 1, + 12, + 1, + 18, + 1, + 24, + 1, + 30, + 1, + 34, + 1, + 39, + 1, + 44, + 1, + 49, + 1, + 54, + 1, + 59, + 1, + 63, + 1, + 67, + 1, + 71, + 1, + 75, + 1, + 79, + 1, + 85, + 1, + 91, + 1, + 97, + 1, + 103, + 1, + 109, + 1, + 115, + 1, + 121, + 1, + 126, + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 125))), + 1, + 27, + 91, + 51, + 74, + 0, + 27, + 91, + 50, + 32, + 113, + 0, + 27, + 91, + 37, + 112, + 49, + 37, + 100, + 32, + 113, + 0, + 27, + 91, + 49, + 59, + 50, + 65, + 0, + 27, + 79, + 120, + 0, + 27, + 79, + 116, + 0, + 27, + 79, + 118, + 0, + 27, + 79, + 114, + 0, + 27, + 79, + 69, + 0, + 27, + 79, + 107, + 0, + 27, + 79, + 108, + 0, + 27, + 79, + 111, + 0, + 27, + 79, + 110, + 0, + 27, + 79, + 106, + 0, + 27, + 79, + 109, + 0, + 27, + 79, + 112, + 0, + 65, + 88, + 0, + 88, + 84, + 0, + 67, + 114, + 0, + 67, + 115, + 0, + 69, + 51, + 0, + 77, + 115, + 0, + 83, + 101, + 0, + 83, + 115, + 0, + 88, + 77, + 0, + 107, + 68, + 67, + 51, + 0, + 107, + 68, + 67, + 52, + 0, + 107, + 68, + 67, + 53, + 0, + 107, + 68, + 67, + 54, + 0, + 107, + 68, + 67, + 55, + 0, + 107, + 68, + 78, + 0, + 107, + 68, + 78, + 51, + 0, + 107, + 68, + 78, + 52, + 0, + 107, + 68, + 78, + 53, + 0, + 107, + 68, + 78, + 54, + 0, + 107, + 68, + 78, + 55, + 0, + 107, + 69, + 78, + 68, + 51, + 0, + 107, + 69, + 78, + 68, + 52, + 0, + 107, + 69, + 78, + 68, + 53, + 0, + 107, + 69, + 78, + 68, + 54, + 0, + 107, + 69, + 78, + 68, + 55, + 0, + 107, + 72, + 79, + 77, + 51, + 0, + 107, + 72, + 79, + 77, + 52, + 0, + 107, + 72, + 79, + 77, + 53, + 0, + 107, + 72, + 79, + 77, + 54, + 0, + 107, + 72, + 79, + 77, + 55, + 0, + 107, + 73, + 67, + 51, + 0, + 107, + 73, + 67, + 52, + 0, + 107, + 73, + 67, + 53, + 0, + 107, + 73, + 67, + 54, + 0, + 107, + 73, + 67, + 55, + 0, + 107, + 76, + 70, + 84, + 51, + 0, + 107, + 76, + 70, + 84, + 52, + 0, + 107, + 76, + 70, + 84, + 53, + 0, + 107, + 76, + 70, + 84, + 54, + 0, + 107, + 76, + 70, + 84, + 55, + 0, + 107, + 78, + 88, + 84, + 51, + 0, + 107, + 78, + 88, + 84, + 52, + 0, + 107, + 78, + 88, + 84, + 53, + 0, + 107, + 78, + 88, + 84, + 54, + 0, + 107, + 78, + 88, + 84, + 55, + 0, + 107, + 80, + 82, + 86, + 51, + 0, + 107, + 80, + 82, + 86, + 52, + 0, + 107, + 80, + 82, + 86, + 53, + 0, + 107, + 80, + 82, + 86, + 54, + 0, + 107, + 80, + 82, + 86, + 55, + 0, + 107, + 82, + 73, + 84, + 51, + 0, + 107, + 82, + 73, + 84, + 52, + 0, + 107, + 82, + 73, + 84, + 53, + 0, + 107, + 82, + 73, + 84, + 54, + 0, + 107, + 82, + 73, + 84, + 55, + 0, + 107, + 85, + 80, + 0, + 107, + 85, + 80, + 51, + 0, + 107, + 85, + 80, + 52, + 0, + 107, + 85, + 80, + 53, + 0, + 107, + 85, + 80, + 54, + 0, + 107, + 85, + 80, + 55, + 0, + 107, + 97, + 50, + 0, + 107, + 98, + 49, + 0, + 107, + 98, + 51, + 0, + 107, + 99, + 50, + 0, + 107, + 112, + 53, + 0, + 107, + 112, + 65, + 68, + 68, + 0, + 107, + 112, + 67, + 77, + 65, + 0, + 107, + 112, + 68, + 73, + 86, + 0, + 107, + 112, + 68, + 79, + 84, + 0, + 107, + 112, + 77, + 85, + 76, + 0, + 107, + 112, + 83, + 85, + 66, + 0, + 107, + 112, + 90, + 82, + 79, + 0, + 114, + 109, + 120, + 120, + 0, + 115, + 109, + 120, + 120, + 0, + 120, + 109, + 0, +}; +pub const cygwin_terminfo: [1518]i8 = [1518]i8{ + 26, + 1, + 33, + 0, + 21, + 0, + 15, + 0, + 125, + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 108))), + 2, + 99, + 121, + 103, + 119, + 105, + 110, + 124, + 65, + 78, + 83, + 73, + 32, + 101, + 109, + 117, + 108, + 97, + 116, + 105, + 111, + 110, + 32, + 102, + 111, + 114, + 32, + 67, + 121, + 103, + 119, + 105, + 110, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 8, + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 8, + 0, + 64, + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 0, + 0, + 2, + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 4, + 0, + 11, + 0, + 15, + 0, + 19, + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 30, + 0, + 47, + 0, + 51, + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 55, + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 57, + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 61, + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 65, + 0, + 69, + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 73, + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 79, + 0, + 84, + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 93, + 0, + 98, + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 103, + 0, + 108, + 0, + 113, + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 118, + 0, + 124, + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 124))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 111))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 106))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 100))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 94))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 92))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 88))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 84))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 82))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 77))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 73))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 68))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 62))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 57))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 52))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 47))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 42))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 36))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 30))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 24))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 18))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 13))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 8))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 4))), + 0, + 1, + 1, + 6, + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 10, + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 14, + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 17, + 1, + 26, + 1, + 35, + 1, + 44, + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 53, + 1, + 62, + 1, + 71, + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 80, + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 89, + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 95, + 1, + 98, + 1, + 109, + 1, + 112, + 1, + 114, + 1, + 117, + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 64))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 62))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 58))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 54))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 9, + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 14, + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 16, + 2, + 22, + 2, + 28, + 2, + 34, + 2, + 40, + 2, + 46, + 2, + 52, + 2, + 58, + 2, + 64, + 2, + 70, + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 76, + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 81, + 2, + 92, + 2, + 97, + 2, + 103, + 2, + 107, + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 116, + 2, + 126, + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 120))), + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 114))), + 2, + 7, + 0, + 13, + 0, + 27, + 91, + 72, + 27, + 91, + 74, + 0, + 27, + 91, + 75, + 0, + 27, + 91, + 74, + 0, + 27, + 91, + 37, + 105, + 37, + 112, + 49, + 37, + 100, + 71, + 0, + 27, + 91, + 37, + 105, + 37, + 112, + 49, + 37, + 100, + 59, + 37, + 112, + 50, + 37, + 100, + 72, + 0, + 27, + 91, + 66, + 0, + 27, + 91, + 72, + 0, + 8, + 0, + 27, + 91, + 67, + 0, + 27, + 91, + 65, + 0, + 27, + 91, + 80, + 0, + 27, + 91, + 77, + 0, + 27, + 91, + 49, + 49, + 109, + 0, + 27, + 91, + 49, + 109, + 0, + 27, + 55, + 27, + 91, + 63, + 52, + 55, + 104, + 0, + 27, + 91, + 52, + 104, + 0, + 27, + 91, + 56, + 109, + 0, + 27, + 91, + 55, + 109, + 0, + 27, + 91, + 55, + 109, + 0, + 27, + 91, + 52, + 109, + 0, + 27, + 91, + 49, + 48, + 109, + 0, + 27, + 91, + 48, + 59, + 49, + 48, + 109, + 0, + 27, + 91, + 50, + 74, + 27, + 91, + 63, + 52, + 55, + 108, + 27, + 56, + 0, + 27, + 91, + 52, + 108, + 0, + 27, + 91, + 50, + 55, + 109, + 0, + 27, + 91, + 50, + 52, + 109, + 0, + 7, + 0, + 27, + 91, + 64, + 0, + 27, + 91, + 76, + 0, + 8, + 0, + 27, + 91, + 51, + 126, + 0, + 27, + 91, + 66, + 0, + 27, + 91, + 91, + 65, + 0, + 27, + 91, + 50, + 49, + 126, + 0, + 27, + 91, + 91, + 66, + 0, + 27, + 91, + 91, + 67, + 0, + 27, + 91, + 91, + 68, + 0, + 27, + 91, + 91, + 69, + 0, + 27, + 91, + 49, + 55, + 126, + 0, + 27, + 91, + 49, + 56, + 126, + 0, + 27, + 91, + 49, + 57, + 126, + 0, + 27, + 91, + 50, + 48, + 126, + 0, + 27, + 91, + 49, + 126, + 0, + 27, + 91, + 50, + 126, + 0, + 27, + 91, + 68, + 0, + 27, + 91, + 54, + 126, + 0, + 27, + 91, + 53, + 126, + 0, + 27, + 91, + 67, + 0, + 27, + 91, + 65, + 0, + 13, + 10, + 0, + 27, + 91, + 37, + 112, + 49, + 37, + 100, + 80, + 0, + 27, + 91, + 37, + 112, + 49, + 37, + 100, + 77, + 0, + 27, + 91, + 37, + 112, + 49, + 37, + 100, + 66, + 0, + 27, + 91, + 37, + 112, + 49, + 37, + 100, + 64, + 0, + 27, + 91, + 37, + 112, + 49, + 37, + 100, + 76, + 0, + 27, + 91, + 37, + 112, + 49, + 37, + 100, + 68, + 0, + 27, + 91, + 37, + 112, + 49, + 37, + 100, + 67, + 0, + 27, + 91, + 37, + 112, + 49, + 37, + 100, + 65, + 0, + 27, + 99, + 27, + 93, + 82, + 0, + 27, + 56, + 0, + 27, + 91, + 37, + 105, + 37, + 112, + 49, + 37, + 100, + 100, + 0, + 27, + 55, + 0, + 10, + 0, + 27, + 77, + 0, + 27, + 91, + 48, + 59, + 49, + 48, + 37, + 63, + 37, + 112, + 49, + 37, + 116, + 59, + 55, + 37, + 59, + 37, + 63, + 37, + 112, + 50, + 37, + 116, + 59, + 52, + 37, + 59, + 37, + 63, + 37, + 112, + 51, + 37, + 116, + 59, + 55, + 37, + 59, + 37, + 63, + 37, + 112, + 54, + 37, + 116, + 59, + 49, + 37, + 59, + 37, + 63, + 37, + 112, + 55, + 37, + 116, + 59, + 56, + 37, + 59, + 37, + 63, + 37, + 112, + 57, + 37, + 116, + 59, + 49, + 49, + 37, + 59, + 109, + 0, + 9, + 0, + 27, + 93, + 59, + 0, + 27, + 91, + 71, + 0, + 43, + 16, + 44, + 17, + 45, + 24, + 46, + 25, + 48, + @bitCast(i8, @truncate(i8, -@as(c_int, 37))), + 96, + 4, + 97, + @bitCast(i8, @truncate(i8, -@as(c_int, 79))), + 102, + @bitCast(i8, @truncate(i8, -@as(c_int, 8))), + 103, + @bitCast(i8, @truncate(i8, -@as(c_int, 15))), + 104, + @bitCast(i8, @truncate(i8, -@as(c_int, 80))), + 106, + @bitCast(i8, @truncate(i8, -@as(c_int, 39))), + 107, + @bitCast(i8, @truncate(i8, -@as(c_int, 65))), + 108, + @bitCast(i8, @truncate(i8, -@as(c_int, 38))), + 109, + @bitCast(i8, @truncate(i8, -@as(c_int, 64))), + 110, + @bitCast(i8, @truncate(i8, -@as(c_int, 59))), + 111, + 126, + 112, + @bitCast(i8, @truncate(i8, -@as(c_int, 60))), + 113, + @bitCast(i8, @truncate(i8, -@as(c_int, 60))), + 114, + @bitCast(i8, @truncate(i8, -@as(c_int, 60))), + 115, + 95, + 116, + @bitCast(i8, @truncate(i8, -@as(c_int, 61))), + 117, + @bitCast(i8, @truncate(i8, -@as(c_int, 76))), + 118, + @bitCast(i8, @truncate(i8, -@as(c_int, 63))), + 119, + @bitCast(i8, @truncate(i8, -@as(c_int, 62))), + 120, + @bitCast(i8, @truncate(i8, -@as(c_int, 77))), + 121, + @bitCast(i8, @truncate(i8, -@as(c_int, 13))), + 122, + @bitCast(i8, @truncate(i8, -@as(c_int, 14))), + 123, + @bitCast(i8, @truncate(i8, -@as(c_int, 29))), + 124, + @bitCast(i8, @truncate(i8, -@as(c_int, 40))), + 125, + @bitCast(i8, @truncate(i8, -@as(c_int, 100))), + 126, + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + 0, + 27, + 91, + 52, + 126, + 0, + 26, + 0, + 27, + 91, + 50, + 51, + 126, + 0, + 27, + 91, + 50, + 52, + 126, + 0, + 27, + 91, + 50, + 53, + 126, + 0, + 27, + 91, + 50, + 54, + 126, + 0, + 27, + 91, + 50, + 56, + 126, + 0, + 27, + 91, + 50, + 57, + 126, + 0, + 27, + 91, + 51, + 49, + 126, + 0, + 27, + 91, + 51, + 50, + 126, + 0, + 27, + 91, + 51, + 51, + 126, + 0, + 27, + 91, + 51, + 52, + 126, + 0, + 27, + 91, + 49, + 75, + 0, + 27, + 91, + 37, + 105, + 37, + 100, + 59, + 37, + 100, + 82, + 0, + 27, + 91, + 54, + 110, + 0, + 27, + 91, + 63, + 54, + 99, + 0, + 27, + 91, + 99, + 0, + 27, + 91, + 51, + 57, + 59, + 52, + 57, + 109, + 0, + 27, + 91, + 51, + 37, + 112, + 49, + 37, + 100, + 109, + 0, + 27, + 91, + 52, + 37, + 112, + 49, + 37, + 100, + 109, + 0, + 27, + 91, + 49, + 49, + 109, + 0, + 27, + 91, + 49, + 48, + 109, + 0, +}; +pub const interix_8colour_terminfo: [1486]i8 = [1486]i8{ + 26, + 1, + 82, + 0, + 29, + 0, + 16, + 0, + 105, + 1, + 96, + 2, + 105, + 110, + 116, + 101, + 114, + 105, + 120, + 124, + 111, + 112, + 101, + 110, + 110, + 116, + 124, + 111, + 112, + 101, + 110, + 110, + 116, + 45, + 50, + 53, + 124, + 110, + 116, + 99, + 111, + 110, + 115, + 111, + 108, + 101, + 124, + 110, + 116, + 99, + 111, + 110, + 115, + 111, + 108, + 101, + 45, + 50, + 53, + 124, + 79, + 112, + 101, + 110, + 78, + 84, + 45, + 116, + 101, + 114, + 109, + 32, + 99, + 111, + 109, + 112, + 97, + 116, + 105, + 98, + 108, + 101, + 32, + 119, + 105, + 116, + 104, + 32, + 99, + 111, + 108, + 111, + 114, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 80, + 0, + 8, + 0, + 25, + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 8, + 0, + 64, + 0, + 3, + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 0, + 0, + 2, + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 4, + 0, + 9, + 0, + 13, + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 17, + 0, + 34, + 0, + 36, + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 40, + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 44, + 0, + 48, + 0, + 52, + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 56, + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 60, + 0, + 65, + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 73, + 0, + 78, + 0, + 83, + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 88, + 0, + 93, + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 105, + 0, + 109, + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 113, + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 117, + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 119, + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 121, + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 125, + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 127))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 123))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 119))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 115))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 111))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 107))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 103))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 99))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 95))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 91))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 87))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 83))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 79))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 75))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 71))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 67))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 63))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 59))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 55))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 51))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 47))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 44))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 35))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 26))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 17))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 8))), + 0, + 1, + 1, + 10, + 1, + 19, + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 28, + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 31, + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 35, + 1, + 39, + 1, + 43, + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 47, + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 49, + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 112, + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 116, + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 120, + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 124, + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 128))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 124))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 120))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 116))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 112))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 108))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 104))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 100))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 96))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 92))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 88))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 84))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 80))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 76))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 72))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 68))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 64))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 60))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 56))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 52))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 48))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 44))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 40))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 36))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 32))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 28))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 24))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 20))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 16))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 12))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 8))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 4))), + 1, + 0, + 2, + 4, + 2, + 8, + 2, + 12, + 2, + 16, + 2, + 20, + 2, + 24, + 2, + 28, + 2, + 32, + 2, + 36, + 2, + 40, + 2, + 44, + 2, + 48, + 2, + 52, + 2, + 56, + 2, + 60, + 2, + 64, + 2, + 68, + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 72, + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 76, + 2, + 86, + 2, + 7, + 0, + 13, + 0, + 27, + 91, + 50, + 74, + 0, + 27, + 91, + 75, + 0, + 27, + 91, + 74, + 0, + 27, + 91, + 37, + 105, + 37, + 112, + 49, + 37, + 100, + 59, + 37, + 112, + 50, + 37, + 100, + 72, + 0, + 10, + 0, + 27, + 91, + 72, + 0, + 27, + 91, + 68, + 0, + 27, + 91, + 67, + 0, + 27, + 91, + 85, + 0, + 27, + 91, + 65, + 0, + 27, + 91, + 77, + 0, + 27, + 91, + 49, + 109, + 0, + 27, + 91, + 115, + 27, + 91, + 49, + 98, + 0, + 27, + 91, + 55, + 109, + 0, + 27, + 91, + 55, + 109, + 0, + 27, + 91, + 52, + 109, + 0, + 27, + 91, + 48, + 109, + 0, + 27, + 91, + 50, + 98, + 27, + 91, + 117, + 13, + 27, + 91, + 75, + 0, + 27, + 91, + 109, + 0, + 27, + 91, + 109, + 0, + 27, + 91, + 76, + 0, + 8, + 0, + 127, + 0, + 27, + 91, + 66, + 0, + 27, + 70, + 65, + 0, + 27, + 70, + 49, + 0, + 27, + 70, + 65, + 0, + 27, + 70, + 50, + 0, + 27, + 70, + 51, + 0, + 27, + 70, + 52, + 0, + 27, + 70, + 53, + 0, + 27, + 70, + 54, + 0, + 27, + 70, + 55, + 0, + 27, + 70, + 56, + 0, + 27, + 70, + 57, + 0, + 27, + 91, + 72, + 0, + 27, + 91, + 76, + 0, + 27, + 91, + 68, + 0, + 27, + 91, + 85, + 0, + 27, + 91, + 84, + 0, + 27, + 91, + 83, + 0, + 27, + 91, + 67, + 0, + 27, + 70, + 43, + 0, + 27, + 70, + 45, + 0, + 27, + 91, + 65, + 0, + 13, + 10, + 0, + 27, + 91, + 37, + 112, + 49, + 37, + 100, + 77, + 0, + 27, + 91, + 37, + 112, + 49, + 37, + 100, + 66, + 0, + 27, + 91, + 37, + 112, + 49, + 37, + 100, + 83, + 0, + 27, + 91, + 37, + 112, + 49, + 37, + 100, + 76, + 0, + 27, + 91, + 37, + 112, + 49, + 37, + 100, + 68, + 0, + 27, + 91, + 37, + 112, + 49, + 37, + 100, + 67, + 0, + 27, + 91, + 37, + 112, + 49, + 37, + 100, + 84, + 0, + 27, + 91, + 37, + 112, + 49, + 37, + 100, + 65, + 0, + 27, + 99, + 0, + 27, + 91, + 117, + 0, + 27, + 91, + 115, + 0, + 27, + 91, + 83, + 0, + 27, + 91, + 84, + 0, + 9, + 0, + 43, + 16, + 44, + 17, + 45, + 24, + 46, + 25, + 48, + @bitCast(i8, @truncate(i8, -@as(c_int, 37))), + 96, + 4, + 97, + @bitCast(i8, @truncate(i8, -@as(c_int, 79))), + 102, + @bitCast(i8, @truncate(i8, -@as(c_int, 8))), + 103, + @bitCast(i8, @truncate(i8, -@as(c_int, 15))), + 104, + @bitCast(i8, @truncate(i8, -@as(c_int, 80))), + 106, + @bitCast(i8, @truncate(i8, -@as(c_int, 39))), + 107, + @bitCast(i8, @truncate(i8, -@as(c_int, 65))), + 108, + @bitCast(i8, @truncate(i8, -@as(c_int, 38))), + 109, + @bitCast(i8, @truncate(i8, -@as(c_int, 64))), + 110, + @bitCast(i8, @truncate(i8, -@as(c_int, 59))), + 111, + 126, + 112, + @bitCast(i8, @truncate(i8, -@as(c_int, 60))), + 113, + @bitCast(i8, @truncate(i8, -@as(c_int, 60))), + 114, + @bitCast(i8, @truncate(i8, -@as(c_int, 60))), + 115, + 95, + 116, + @bitCast(i8, @truncate(i8, -@as(c_int, 61))), + 117, + @bitCast(i8, @truncate(i8, -@as(c_int, 76))), + 118, + @bitCast(i8, @truncate(i8, -@as(c_int, 63))), + 119, + @bitCast(i8, @truncate(i8, -@as(c_int, 62))), + 120, + @bitCast(i8, @truncate(i8, -@as(c_int, 77))), + 121, + @bitCast(i8, @truncate(i8, -@as(c_int, 13))), + 122, + @bitCast(i8, @truncate(i8, -@as(c_int, 14))), + 123, + @bitCast(i8, @truncate(i8, -@as(c_int, 29))), + 124, + @bitCast(i8, @truncate(i8, -@as(c_int, 40))), + 125, + @bitCast(i8, @truncate(i8, -@as(c_int, 100))), + 126, + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + 0, + 27, + 91, + 90, + 0, + 27, + 91, + 85, + 0, + 27, + 70, + 94, + 0, + 27, + 70, + 36, + 0, + 27, + 70, + 66, + 0, + 27, + 70, + 67, + 0, + 27, + 70, + 68, + 0, + 27, + 70, + 69, + 0, + 27, + 70, + 70, + 0, + 27, + 70, + 71, + 0, + 27, + 70, + 72, + 0, + 27, + 70, + 73, + 0, + 27, + 70, + 74, + 0, + 27, + 70, + 75, + 0, + 27, + 70, + 76, + 0, + 27, + 70, + 77, + 0, + 27, + 70, + 78, + 0, + 27, + 70, + 79, + 0, + 27, + 70, + 80, + 0, + 27, + 70, + 81, + 0, + 27, + 70, + 82, + 0, + 27, + 70, + 83, + 0, + 27, + 70, + 84, + 0, + 27, + 70, + 85, + 0, + 27, + 70, + 86, + 0, + 27, + 70, + 87, + 0, + 27, + 70, + 88, + 0, + 27, + 70, + 89, + 0, + 27, + 70, + 90, + 0, + 27, + 70, + 97, + 0, + 27, + 70, + 98, + 0, + 27, + 70, + 99, + 0, + 27, + 70, + 100, + 0, + 27, + 70, + 101, + 0, + 27, + 70, + 102, + 0, + 27, + 70, + 103, + 0, + 27, + 70, + 104, + 0, + 27, + 70, + 105, + 0, + 27, + 70, + 106, + 0, + 27, + 70, + 107, + 0, + 27, + 70, + 109, + 0, + 27, + 70, + 110, + 0, + 27, + 70, + 111, + 0, + 27, + 70, + 112, + 0, + 27, + 70, + 113, + 0, + 27, + 70, + 114, + 0, + 27, + 70, + 115, + 0, + 27, + 70, + 116, + 0, + 27, + 70, + 117, + 0, + 27, + 70, + 118, + 0, + 27, + 70, + 119, + 0, + 27, + 70, + 120, + 0, + 27, + 70, + 121, + 0, + 27, + 70, + 122, + 0, + 27, + 91, + 109, + 0, + 27, + 91, + 51, + 37, + 112, + 49, + 37, + 100, + 109, + 0, + 27, + 91, + 52, + 37, + 112, + 49, + 37, + 100, + 109, + 0, +}; +pub const iterm_256colour_terminfo: [2485]i8 = [2485]i8{ + 30, + 2, + 49, + 0, + 29, + 0, + 15, + 0, + 105, + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 29))), + 3, + 105, + 84, + 101, + 114, + 109, + 50, + 46, + 97, + 112, + 112, + 124, + 105, + 116, + 101, + 114, + 109, + 50, + 124, + 116, + 101, + 114, + 109, + 105, + 110, + 97, + 108, + 32, + 101, + 109, + 117, + 108, + 97, + 116, + 111, + 114, + 32, + 102, + 111, + 114, + 32, + 77, + 97, + 99, + 32, + 79, + 83, + 32, + 88, + 0, + 0, + 1, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 80, + 0, + 0, + 0, + 8, + 0, + 0, + 0, + 24, + 0, + 0, + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 50, + 0, + 0, + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 0, + 1, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 4, + 0, + 6, + 0, + 8, + 0, + 25, + 0, + 30, + 0, + 37, + 0, + 41, + 0, + 45, + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 56, + 0, + 73, + 0, + 75, + 0, + 79, + 0, + 86, + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 88, + 0, + 95, + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 99, + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 103, + 0, + 107, + 0, + 111, + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 117, + 0, + 119, + 0, + 124, + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 127))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 109))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 104))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 99))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 94))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 89))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 84))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 82))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 77))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 59))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 54))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 48))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 42))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 24))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 22))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 18))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 14))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 12))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 7))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 3))), + 0, + 1, + 1, + 7, + 1, + 11, + 1, + 15, + 1, + 19, + 1, + 25, + 1, + 31, + 1, + 37, + 1, + 43, + 1, + 49, + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 53, + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 57, + 1, + 62, + 1, + 67, + 1, + 71, + 1, + 78, + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 85, + 1, + 89, + 1, + 97, + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 105, + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 108, + 1, + 117, + 1, + 126, + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 121))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 112))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 103))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 94))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 85))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 76))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 67))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 58))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 32))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 29))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 18))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 15))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 13))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 10))), + 1, + 68, + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 71, + 2, + 73, + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 78, + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 127))), + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 123))), + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 117))), + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 111))), + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 104))), + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 100))), + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 93))), + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 86))), + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 79))), + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 72))), + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 66))), + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 60))), + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 53))), + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 46))), + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 39))), + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 32))), + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 24))), + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 16))), + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 8))), + 2, + 0, + 3, + 8, + 3, + 16, + 3, + 24, + 3, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 32, + 3, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 37, + 3, + 48, + 3, + 53, + 3, + 72, + 3, + 76, + 3, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 85, + 3, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 90, + 3, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 96, + 3, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 100, + 3, + @bitCast(i8, @truncate(i8, -@as(c_int, 93))), + 3, + 27, + 91, + 90, + 0, + 7, + 0, + 13, + 0, + 27, + 91, + 37, + 105, + 37, + 112, + 49, + 37, + 100, + 59, + 37, + 112, + 50, + 37, + 100, + 114, + 0, + 27, + 91, + 51, + 103, + 0, + 27, + 91, + 72, + 27, + 91, + 74, + 0, + 27, + 91, + 75, + 0, + 27, + 91, + 74, + 0, + 27, + 91, + 37, + 105, + 37, + 112, + 49, + 37, + 100, + 71, + 0, + 27, + 91, + 37, + 105, + 37, + 112, + 49, + 37, + 100, + 59, + 37, + 112, + 50, + 37, + 100, + 72, + 0, + 10, + 0, + 27, + 91, + 72, + 0, + 27, + 91, + 63, + 50, + 53, + 108, + 0, + 8, + 0, + 27, + 91, + 63, + 50, + 53, + 104, + 0, + 27, + 91, + 67, + 0, + 27, + 91, + 65, + 0, + 27, + 91, + 80, + 0, + 27, + 91, + 77, + 0, + 27, + 93, + 50, + 59, + 7, + 0, + 14, + 0, + 27, + 91, + 53, + 109, + 0, + 27, + 91, + 49, + 109, + 0, + 27, + 91, + 63, + 49, + 48, + 52, + 57, + 104, + 27, + 91, + 50, + 50, + 59, + 48, + 59, + 48, + 116, + 0, + 27, + 91, + 50, + 109, + 0, + 27, + 91, + 52, + 104, + 0, + 27, + 91, + 55, + 109, + 0, + 27, + 91, + 55, + 109, + 0, + 27, + 91, + 52, + 109, + 0, + 15, + 0, + 27, + 91, + 109, + 15, + 0, + 27, + 91, + 63, + 49, + 48, + 52, + 57, + 108, + 27, + 91, + 50, + 51, + 59, + 48, + 59, + 48, + 116, + 0, + 27, + 91, + 52, + 108, + 0, + 27, + 91, + 50, + 55, + 109, + 0, + 27, + 91, + 50, + 52, + 109, + 0, + 27, + 91, + 63, + 53, + 104, + 36, + 60, + 50, + 48, + 48, + 47, + 62, + 27, + 91, + 63, + 53, + 108, + 0, + 7, + 0, + 27, + 91, + 64, + 0, + 27, + 91, + 76, + 0, + 127, + 0, + 27, + 91, + 51, + 126, + 0, + 27, + 79, + 66, + 0, + 27, + 79, + 80, + 0, + 27, + 91, + 50, + 49, + 126, + 0, + 27, + 79, + 81, + 0, + 27, + 79, + 82, + 0, + 27, + 79, + 83, + 0, + 27, + 91, + 49, + 53, + 126, + 0, + 27, + 91, + 49, + 55, + 126, + 0, + 27, + 91, + 49, + 56, + 126, + 0, + 27, + 91, + 49, + 57, + 126, + 0, + 27, + 91, + 50, + 48, + 126, + 0, + 27, + 79, + 72, + 0, + 27, + 79, + 68, + 0, + 27, + 91, + 54, + 126, + 0, + 27, + 91, + 53, + 126, + 0, + 27, + 79, + 67, + 0, + 27, + 91, + 49, + 59, + 50, + 66, + 0, + 27, + 91, + 49, + 59, + 50, + 65, + 0, + 27, + 79, + 65, + 0, + 27, + 91, + 63, + 49, + 108, + 27, + 62, + 0, + 27, + 91, + 63, + 49, + 104, + 27, + 61, + 0, + 27, + 69, + 0, + 27, + 91, + 37, + 112, + 49, + 37, + 100, + 80, + 0, + 27, + 91, + 37, + 112, + 49, + 37, + 100, + 77, + 0, + 27, + 91, + 37, + 112, + 49, + 37, + 100, + 66, + 0, + 27, + 91, + 37, + 112, + 49, + 37, + 100, + 64, + 0, + 27, + 91, + 37, + 112, + 49, + 37, + 100, + 83, + 0, + 27, + 91, + 37, + 112, + 49, + 37, + 100, + 76, + 0, + 27, + 91, + 37, + 112, + 49, + 37, + 100, + 68, + 0, + 27, + 91, + 37, + 112, + 49, + 37, + 100, + 67, + 0, + 27, + 91, + 37, + 112, + 49, + 37, + 100, + 84, + 0, + 27, + 91, + 37, + 112, + 49, + 37, + 100, + 65, + 0, + 27, + 91, + 33, + 112, + 27, + 91, + 63, + 51, + 59, + 52, + 108, + 27, + 91, + 52, + 108, + 27, + 62, + 27, + 91, + 63, + 49, + 48, + 48, + 48, + 108, + 0, + 27, + 56, + 0, + 27, + 91, + 37, + 105, + 37, + 112, + 49, + 37, + 100, + 100, + 0, + 27, + 55, + 0, + 10, + 0, + 27, + 77, + 0, + 27, + 91, + 48, + 37, + 63, + 37, + 112, + 54, + 37, + 116, + 59, + 49, + 37, + 59, + 37, + 63, + 37, + 112, + 50, + 37, + 116, + 59, + 52, + 37, + 59, + 37, + 63, + 37, + 112, + 49, + 37, + 112, + 51, + 37, + 124, + 37, + 116, + 59, + 55, + 37, + 59, + 37, + 63, + 37, + 112, + 52, + 37, + 116, + 59, + 53, + 37, + 59, + 37, + 63, + 37, + 112, + 53, + 37, + 116, + 59, + 50, + 37, + 59, + 109, + 37, + 63, + 37, + 112, + 57, + 37, + 116, + 14, + 37, + 101, + 15, + 37, + 59, + 0, + 27, + 72, + 0, + 9, + 0, + 27, + 93, + 50, + 59, + 0, + 96, + 96, + 97, + 97, + 102, + 102, + 103, + 103, + 106, + 106, + 107, + 107, + 108, + 108, + 109, + 109, + 110, + 110, + 111, + 111, + 112, + 112, + 113, + 113, + 114, + 114, + 115, + 115, + 116, + 116, + 117, + 117, + 118, + 118, + 119, + 119, + 120, + 120, + 121, + 121, + 122, + 122, + 123, + 123, + 124, + 124, + 125, + 125, + 126, + 126, + 0, + 27, + 91, + 90, + 0, + 27, + 91, + 63, + 55, + 104, + 0, + 27, + 91, + 63, + 55, + 108, + 0, + 27, + 40, + 66, + 27, + 41, + 48, + 0, + 27, + 79, + 70, + 0, + 27, + 91, + 49, + 59, + 50, + 70, + 0, + 27, + 91, + 49, + 59, + 50, + 72, + 0, + 27, + 91, + 49, + 59, + 50, + 68, + 0, + 27, + 91, + 49, + 59, + 50, + 67, + 0, + 27, + 91, + 50, + 51, + 126, + 0, + 27, + 91, + 50, + 52, + 126, + 0, + 27, + 91, + 49, + 59, + 50, + 80, + 0, + 27, + 91, + 49, + 59, + 50, + 81, + 0, + 27, + 91, + 49, + 59, + 50, + 82, + 0, + 27, + 91, + 49, + 59, + 50, + 83, + 0, + 27, + 91, + 49, + 53, + 59, + 50, + 126, + 0, + 27, + 91, + 49, + 55, + 59, + 50, + 126, + 0, + 27, + 91, + 49, + 56, + 59, + 50, + 126, + 0, + 27, + 91, + 49, + 57, + 59, + 50, + 126, + 0, + 27, + 91, + 50, + 48, + 59, + 50, + 126, + 0, + 27, + 91, + 50, + 49, + 59, + 50, + 126, + 0, + 27, + 91, + 50, + 51, + 59, + 50, + 126, + 0, + 27, + 91, + 50, + 52, + 59, + 50, + 126, + 0, + 27, + 91, + 49, + 75, + 0, + 27, + 91, + 37, + 105, + 37, + 100, + 59, + 37, + 100, + 82, + 0, + 27, + 91, + 54, + 110, + 0, + 27, + 91, + 63, + 37, + 91, + 59, + 48, + 49, + 50, + 51, + 52, + 53, + 54, + 55, + 56, + 57, + 93, + 99, + 0, + 27, + 91, + 99, + 0, + 27, + 91, + 51, + 57, + 59, + 52, + 57, + 109, + 0, + 27, + 91, + 51, + 109, + 0, + 27, + 91, + 50, + 51, + 109, + 0, + 27, + 91, + 77, + 0, + 27, + 91, + 37, + 63, + 37, + 112, + 49, + 37, + 123, + 56, + 125, + 37, + 60, + 37, + 116, + 51, + 37, + 112, + 49, + 37, + 100, + 37, + 101, + 37, + 112, + 49, + 37, + 123, + 49, + 54, + 125, + 37, + 60, + 37, + 116, + 57, + 37, + 112, + 49, + 37, + 123, + 56, + 125, + 37, + 45, + 37, + 100, + 37, + 101, + 51, + 56, + 59, + 53, + 59, + 37, + 112, + 49, + 37, + 100, + 37, + 59, + 109, + 0, + 27, + 91, + 37, + 63, + 37, + 112, + 49, + 37, + 123, + 56, + 125, + 37, + 60, + 37, + 116, + 52, + 37, + 112, + 49, + 37, + 100, + 37, + 101, + 37, + 112, + 49, + 37, + 123, + 49, + 54, + 125, + 37, + 60, + 37, + 116, + 49, + 48, + 37, + 112, + 49, + 37, + 123, + 56, + 125, + 37, + 45, + 37, + 100, + 37, + 101, + 52, + 56, + 59, + 53, + 59, + 37, + 112, + 49, + 37, + 100, + 37, + 59, + 109, + 0, + 0, + 0, + 0, + 0, + 0, + 33, + 0, + 66, + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 37))), + 1, + 0, + 0, + 5, + 0, + 32, + 0, + 37, + 0, + 45, + 0, + 52, + 0, + 59, + 0, + 66, + 0, + 74, + 0, + 81, + 0, + 88, + 0, + 96, + 0, + 104, + 0, + 111, + 0, + 119, + 0, + 126, + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 123))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 115))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 107))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 102))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 94))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 87))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 80))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 74))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 68))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 63))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 55))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 48))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 41))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 36))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 28))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 21))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 14))), + 0, + 0, + 0, + 3, + 0, + 6, + 0, + 11, + 0, + 16, + 0, + 21, + 0, + 26, + 0, + 32, + 0, + 38, + 0, + 44, + 0, + 50, + 0, + 56, + 0, + 62, + 0, + 68, + 0, + 74, + 0, + 80, + 0, + 86, + 0, + 92, + 0, + 98, + 0, + 104, + 0, + 110, + 0, + 116, + 0, + 122, + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 128))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 122))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 116))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 110))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 104))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 98))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 93))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 88))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 83))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 78))), + 0, + 27, + 93, + 50, + 59, + 0, + 27, + 91, + 63, + 49, + 48, + 48, + 48, + 37, + 63, + 37, + 112, + 49, + 37, + 123, + 49, + 125, + 37, + 61, + 37, + 116, + 104, + 37, + 101, + 108, + 37, + 59, + 0, + 27, + 27, + 91, + 66, + 0, + 27, + 91, + 49, + 59, + 49, + 48, + 66, + 0, + 27, + 91, + 49, + 59, + 53, + 66, + 0, + 27, + 91, + 49, + 59, + 54, + 66, + 0, + 27, + 91, + 49, + 59, + 57, + 70, + 0, + 27, + 91, + 49, + 59, + 49, + 48, + 70, + 0, + 27, + 91, + 49, + 59, + 53, + 70, + 0, + 27, + 91, + 49, + 59, + 54, + 70, + 0, + 27, + 91, + 49, + 59, + 49, + 51, + 70, + 0, + 27, + 91, + 49, + 59, + 49, + 52, + 70, + 0, + 27, + 91, + 49, + 59, + 57, + 72, + 0, + 27, + 91, + 49, + 59, + 49, + 48, + 72, + 0, + 27, + 91, + 49, + 59, + 53, + 72, + 0, + 27, + 91, + 49, + 59, + 54, + 72, + 0, + 27, + 91, + 49, + 59, + 49, + 51, + 72, + 0, + 27, + 91, + 49, + 59, + 49, + 52, + 72, + 0, + 27, + 27, + 91, + 68, + 0, + 27, + 91, + 49, + 59, + 49, + 48, + 68, + 0, + 27, + 91, + 49, + 59, + 53, + 68, + 0, + 27, + 91, + 49, + 59, + 54, + 68, + 0, + 27, + 27, + 91, + 54, + 126, + 0, + 27, + 27, + 91, + 53, + 126, + 0, + 27, + 27, + 91, + 67, + 0, + 27, + 91, + 49, + 59, + 49, + 48, + 67, + 0, + 27, + 91, + 49, + 59, + 53, + 67, + 0, + 27, + 91, + 49, + 59, + 54, + 67, + 0, + 27, + 27, + 91, + 65, + 0, + 27, + 91, + 49, + 59, + 49, + 48, + 65, + 0, + 27, + 91, + 49, + 59, + 53, + 65, + 0, + 27, + 91, + 49, + 59, + 54, + 65, + 0, + 27, + 91, + 77, + 37, + 63, + 37, + 112, + 52, + 37, + 116, + 37, + 112, + 51, + 37, + 101, + 37, + 123, + 51, + 125, + 37, + 59, + 37, + 39, + 32, + 39, + 37, + 43, + 37, + 99, + 37, + 112, + 50, + 37, + 39, + 33, + 39, + 37, + 43, + 37, + 99, + 37, + 112, + 49, + 37, + 39, + 33, + 39, + 37, + 43, + 37, + 99, + 0, + 84, + 83, + 0, + 88, + 77, + 0, + 107, + 68, + 78, + 51, + 0, + 107, + 68, + 78, + 52, + 0, + 107, + 68, + 78, + 53, + 0, + 107, + 68, + 78, + 54, + 0, + 107, + 69, + 78, + 68, + 51, + 0, + 107, + 69, + 78, + 68, + 52, + 0, + 107, + 69, + 78, + 68, + 53, + 0, + 107, + 69, + 78, + 68, + 54, + 0, + 107, + 69, + 78, + 68, + 55, + 0, + 107, + 69, + 78, + 68, + 56, + 0, + 107, + 72, + 79, + 77, + 51, + 0, + 107, + 72, + 79, + 77, + 52, + 0, + 107, + 72, + 79, + 77, + 53, + 0, + 107, + 72, + 79, + 77, + 54, + 0, + 107, + 72, + 79, + 77, + 55, + 0, + 107, + 72, + 79, + 77, + 56, + 0, + 107, + 76, + 70, + 84, + 51, + 0, + 107, + 76, + 70, + 84, + 52, + 0, + 107, + 76, + 70, + 84, + 53, + 0, + 107, + 76, + 70, + 84, + 54, + 0, + 107, + 78, + 88, + 84, + 51, + 0, + 107, + 80, + 82, + 86, + 51, + 0, + 107, + 82, + 73, + 84, + 51, + 0, + 107, + 82, + 73, + 84, + 52, + 0, + 107, + 82, + 73, + 84, + 53, + 0, + 107, + 82, + 73, + 84, + 54, + 0, + 107, + 85, + 80, + 51, + 0, + 107, + 85, + 80, + 52, + 0, + 107, + 85, + 80, + 53, + 0, + 107, + 85, + 80, + 54, + 0, + 120, + 109, + 0, +}; +pub const linux_16colour_terminfo: [1728]i8 = [1728]i8{ + 26, + 1, + 20, + 0, + 29, + 0, + 16, + 0, + 125, + 1, + 67, + 3, + 108, + 105, + 110, + 117, + 120, + 124, + 108, + 105, + 110, + 117, + 120, + 32, + 99, + 111, + 110, + 115, + 111, + 108, + 101, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 8, + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 8, + 0, + 64, + 0, + 18, + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 0, + 0, + 2, + 0, + 4, + 0, + 21, + 0, + 26, + 0, + 33, + 0, + 37, + 0, + 41, + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 52, + 0, + 69, + 0, + 71, + 0, + 75, + 0, + 87, + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 89, + 0, + 101, + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 105, + 0, + 109, + 0, + 121, + 0, + 125, + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 127))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 125))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 120))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 115))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 110))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 105))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 100))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 95))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 90))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 81))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 79))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 74))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 69))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 63))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 57))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 39))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 35))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 31))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 29))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 24))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 20))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 15))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 9))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 4))), + 0, + 1, + 1, + 6, + 1, + 11, + 1, + 17, + 1, + 23, + 1, + 29, + 1, + 35, + 1, + 40, + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 45, + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 49, + 1, + 54, + 1, + 59, + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 63, + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 67, + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 70, + 1, + 79, + 1, + 88, + 1, + 97, + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 106, + 1, + 115, + 1, + 124, + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 123))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 114))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 108))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 105))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 94))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 91))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 89))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 86))), + 1, + 1, + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 4, + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 6, + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 10, + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 75, + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 79, + 2, + 85, + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 91, + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 95, + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 100, + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 102, + 2, + 108, + 2, + 114, + 2, + 120, + 2, + 126, + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 124))), + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 118))), + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 112))), + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 106))), + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 100))), + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 94))), + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 89))), + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 78))), + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 73))), + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 67))), + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 63))), + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 54))), + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 50))), + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 31, + 3, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 35, + 3, + 45, + 3, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 55, + 3, + 61, + 3, + 7, + 0, + 13, + 0, + 27, + 91, + 37, + 105, + 37, + 112, + 49, + 37, + 100, + 59, + 37, + 112, + 50, + 37, + 100, + 114, + 0, + 27, + 91, + 51, + 103, + 0, + 27, + 91, + 72, + 27, + 91, + 74, + 0, + 27, + 91, + 75, + 0, + 27, + 91, + 74, + 0, + 27, + 91, + 37, + 105, + 37, + 112, + 49, + 37, + 100, + 71, + 0, + 27, + 91, + 37, + 105, + 37, + 112, + 49, + 37, + 100, + 59, + 37, + 112, + 50, + 37, + 100, + 72, + 0, + 10, + 0, + 27, + 91, + 72, + 0, + 27, + 91, + 63, + 50, + 53, + 108, + 27, + 91, + 63, + 49, + 99, + 0, + 8, + 0, + 27, + 91, + 63, + 50, + 53, + 104, + 27, + 91, + 63, + 48, + 99, + 0, + 27, + 91, + 67, + 0, + 27, + 91, + 65, + 0, + 27, + 91, + 63, + 50, + 53, + 104, + 27, + 91, + 63, + 56, + 99, + 0, + 27, + 91, + 80, + 0, + 27, + 91, + 77, + 0, + 14, + 0, + 27, + 91, + 53, + 109, + 0, + 27, + 91, + 49, + 109, + 0, + 27, + 91, + 50, + 109, + 0, + 27, + 91, + 52, + 104, + 0, + 27, + 91, + 55, + 109, + 0, + 27, + 91, + 55, + 109, + 0, + 27, + 91, + 52, + 109, + 0, + 27, + 91, + 37, + 112, + 49, + 37, + 100, + 88, + 0, + 15, + 0, + 27, + 91, + 109, + 15, + 0, + 27, + 91, + 52, + 108, + 0, + 27, + 91, + 50, + 55, + 109, + 0, + 27, + 91, + 50, + 52, + 109, + 0, + 27, + 91, + 63, + 53, + 104, + 36, + 60, + 50, + 48, + 48, + 47, + 62, + 27, + 91, + 63, + 53, + 108, + 0, + 27, + 91, + 64, + 0, + 27, + 91, + 76, + 0, + 127, + 0, + 27, + 91, + 51, + 126, + 0, + 27, + 91, + 66, + 0, + 27, + 91, + 91, + 65, + 0, + 27, + 91, + 50, + 49, + 126, + 0, + 27, + 91, + 91, + 66, + 0, + 27, + 91, + 91, + 67, + 0, + 27, + 91, + 91, + 68, + 0, + 27, + 91, + 91, + 69, + 0, + 27, + 91, + 49, + 55, + 126, + 0, + 27, + 91, + 49, + 56, + 126, + 0, + 27, + 91, + 49, + 57, + 126, + 0, + 27, + 91, + 50, + 48, + 126, + 0, + 27, + 91, + 49, + 126, + 0, + 27, + 91, + 50, + 126, + 0, + 27, + 91, + 68, + 0, + 27, + 91, + 54, + 126, + 0, + 27, + 91, + 53, + 126, + 0, + 27, + 91, + 67, + 0, + 27, + 91, + 65, + 0, + 13, + 10, + 0, + 27, + 91, + 37, + 112, + 49, + 37, + 100, + 80, + 0, + 27, + 91, + 37, + 112, + 49, + 37, + 100, + 77, + 0, + 27, + 91, + 37, + 112, + 49, + 37, + 100, + 66, + 0, + 27, + 91, + 37, + 112, + 49, + 37, + 100, + 64, + 0, + 27, + 91, + 37, + 112, + 49, + 37, + 100, + 76, + 0, + 27, + 91, + 37, + 112, + 49, + 37, + 100, + 68, + 0, + 27, + 91, + 37, + 112, + 49, + 37, + 100, + 67, + 0, + 27, + 91, + 37, + 112, + 49, + 37, + 100, + 65, + 0, + 27, + 99, + 27, + 93, + 82, + 0, + 27, + 56, + 0, + 27, + 91, + 37, + 105, + 37, + 112, + 49, + 37, + 100, + 100, + 0, + 27, + 55, + 0, + 10, + 0, + 27, + 77, + 0, + 27, + 91, + 48, + 59, + 49, + 48, + 37, + 63, + 37, + 112, + 49, + 37, + 116, + 59, + 55, + 37, + 59, + 37, + 63, + 37, + 112, + 50, + 37, + 116, + 59, + 52, + 37, + 59, + 37, + 63, + 37, + 112, + 51, + 37, + 116, + 59, + 55, + 37, + 59, + 37, + 63, + 37, + 112, + 52, + 37, + 116, + 59, + 53, + 37, + 59, + 37, + 63, + 37, + 112, + 53, + 37, + 116, + 59, + 50, + 37, + 59, + 37, + 63, + 37, + 112, + 54, + 37, + 116, + 59, + 49, + 37, + 59, + 109, + 37, + 63, + 37, + 112, + 57, + 37, + 116, + 14, + 37, + 101, + 15, + 37, + 59, + 0, + 27, + 72, + 0, + 9, + 0, + 27, + 91, + 71, + 0, + 43, + 43, + 44, + 44, + 45, + 45, + 46, + 46, + 48, + 48, + 96, + 96, + 97, + 97, + 102, + 102, + 103, + 103, + 104, + 104, + 105, + 105, + 106, + 106, + 107, + 107, + 108, + 108, + 109, + 109, + 110, + 110, + 111, + 111, + 112, + 112, + 113, + 113, + 114, + 114, + 115, + 115, + 116, + 116, + 117, + 117, + 118, + 118, + 119, + 119, + 120, + 120, + 121, + 121, + 122, + 122, + 123, + 123, + 124, + 124, + 125, + 125, + 126, + 126, + 0, + 27, + 91, + 90, + 0, + 27, + 91, + 63, + 55, + 104, + 0, + 27, + 91, + 63, + 55, + 108, + 0, + 27, + 41, + 48, + 0, + 27, + 91, + 52, + 126, + 0, + 26, + 0, + 27, + 91, + 50, + 51, + 126, + 0, + 27, + 91, + 50, + 52, + 126, + 0, + 27, + 91, + 50, + 53, + 126, + 0, + 27, + 91, + 50, + 54, + 126, + 0, + 27, + 91, + 50, + 56, + 126, + 0, + 27, + 91, + 50, + 57, + 126, + 0, + 27, + 91, + 51, + 49, + 126, + 0, + 27, + 91, + 51, + 50, + 126, + 0, + 27, + 91, + 51, + 51, + 126, + 0, + 27, + 91, + 51, + 52, + 126, + 0, + 27, + 91, + 49, + 75, + 0, + 27, + 91, + 37, + 105, + 37, + 100, + 59, + 37, + 100, + 82, + 0, + 27, + 91, + 54, + 110, + 0, + 27, + 91, + 63, + 54, + 99, + 0, + 27, + 91, + 99, + 0, + 27, + 91, + 51, + 57, + 59, + 52, + 57, + 109, + 0, + 27, + 93, + 82, + 0, + 27, + 93, + 80, + 37, + 112, + 49, + 37, + 120, + 37, + 112, + 50, + 37, + 123, + 50, + 53, + 53, + 125, + 37, + 42, + 37, + 123, + 49, + 48, + 48, + 48, + 125, + 37, + 47, + 37, + 48, + 50, + 120, + 37, + 112, + 51, + 37, + 123, + 50, + 53, + 53, + 125, + 37, + 42, + 37, + 123, + 49, + 48, + 48, + 48, + 125, + 37, + 47, + 37, + 48, + 50, + 120, + 37, + 112, + 52, + 37, + 123, + 50, + 53, + 53, + 125, + 37, + 42, + 37, + 123, + 49, + 48, + 48, + 48, + 125, + 37, + 47, + 37, + 48, + 50, + 120, + 0, + 27, + 91, + 77, + 0, + 27, + 91, + 51, + 37, + 112, + 49, + 37, + 100, + 109, + 0, + 27, + 91, + 52, + 37, + 112, + 49, + 37, + 100, + 109, + 0, + 27, + 91, + 49, + 49, + 109, + 0, + 27, + 91, + 49, + 48, + 109, + 0, + 0, + 1, + 0, + 1, + 0, + 1, + 0, + 4, + 0, + 14, + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 3, + 0, + 6, + 0, + 27, + 91, + 51, + 74, + 0, + 65, + 88, + 0, + 85, + 56, + 0, + 69, + 51, + 0, +}; +pub const putty_256colour_terminfo: [2465]i8 = [2465]i8{ + 30, + 2, + 48, + 0, + 29, + 0, + 16, + 0, + 125, + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 70))), + 4, + 112, + 117, + 116, + 116, + 121, + 45, + 50, + 53, + 54, + 99, + 111, + 108, + 111, + 114, + 124, + 80, + 117, + 84, + 84, + 89, + 32, + 48, + 46, + 53, + 56, + 32, + 119, + 105, + 116, + 104, + 32, + 120, + 116, + 101, + 114, + 109, + 32, + 50, + 53, + 54, + 45, + 99, + 111, + 108, + 111, + 114, + 115, + 0, + 1, + 1, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 8, + 0, + 0, + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 0, + 1, + 0, + 0, + 0, + 0, + 1, + 0, + 22, + 0, + 0, + 0, + 0, + 0, + 4, + 0, + 6, + 0, + 8, + 0, + 25, + 0, + 30, + 0, + 37, + 0, + 41, + 0, + 45, + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 56, + 0, + 73, + 0, + 76, + 0, + 80, + 0, + 87, + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 89, + 0, + 96, + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 100, + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 103, + 0, + 107, + 0, + 111, + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 117, + 0, + 119, + 0, + 124, + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 127))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 120))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 115))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 110))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 105))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 100))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 91))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 89))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 84))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 73))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 68))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 62))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 56))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 38))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 36))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 2, + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 4, + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 9, + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 13, + 1, + 17, + 1, + 23, + 1, + 29, + 1, + 35, + 1, + 41, + 1, + 47, + 1, + 53, + 1, + 59, + 1, + 65, + 1, + 71, + 1, + 77, + 1, + 82, + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 87, + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 91, + 1, + 96, + 1, + 101, + 1, + 105, + 1, + 109, + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 113, + 1, + 117, + 1, + 125, + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 123))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 120))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 111))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 102))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 93))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 84))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 75))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 66))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 57))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 48))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 39))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 19))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 14, + 2, + 17, + 2, + 28, + 2, + 31, + 2, + 33, + 2, + 36, + 2, + 108, + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 111, + 2, + 113, + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 118, + 2, + 122, + 2, + 126, + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 126))), + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 122))), + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 118))), + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 67))), + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 63))), + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 57))), + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 51))), + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 44))), + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 39))), + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 35))), + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 33))), + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 27))), + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 21))), + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 15))), + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 9))), + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 3))), + 2, + 3, + 3, + 9, + 3, + 15, + 3, + 21, + 3, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 27, + 3, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 32, + 3, + 43, + 3, + 48, + 3, + 54, + 3, + 58, + 3, + 67, + 3, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 71, + 3, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 75, + 3, + @bitCast(i8, @truncate(i8, -@as(c_int, 118))), + 3, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 54))), + 3, + @bitCast(i8, @truncate(i8, -@as(c_int, 48))), + 3, + @bitCast(i8, @truncate(i8, -@as(c_int, 42))), + 3, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 36))), + 3, + @bitCast(i8, @truncate(i8, -@as(c_int, 82))), + 4, + @bitCast(i8, @truncate(i8, -@as(c_int, 76))), + 4, + 27, + 91, + 90, + 0, + 7, + 0, + 13, + 0, + 27, + 91, + 37, + 105, + 37, + 112, + 49, + 37, + 100, + 59, + 37, + 112, + 50, + 37, + 100, + 114, + 0, + 27, + 91, + 51, + 103, + 0, + 27, + 91, + 72, + 27, + 91, + 74, + 0, + 27, + 91, + 75, + 0, + 27, + 91, + 74, + 0, + 27, + 91, + 37, + 105, + 37, + 112, + 49, + 37, + 100, + 71, + 0, + 27, + 91, + 37, + 105, + 37, + 112, + 49, + 37, + 100, + 59, + 37, + 112, + 50, + 37, + 100, + 72, + 0, + 27, + 68, + 0, + 27, + 91, + 72, + 0, + 27, + 91, + 63, + 50, + 53, + 108, + 0, + 8, + 0, + 27, + 91, + 63, + 50, + 53, + 104, + 0, + 27, + 91, + 67, + 0, + 27, + 77, + 0, + 27, + 91, + 80, + 0, + 27, + 91, + 77, + 0, + 27, + 93, + 48, + 59, + 7, + 0, + 14, + 0, + 27, + 91, + 53, + 109, + 0, + 27, + 91, + 49, + 109, + 0, + 27, + 91, + 63, + 52, + 55, + 104, + 0, + 27, + 91, + 52, + 104, + 0, + 27, + 91, + 55, + 109, + 0, + 27, + 91, + 55, + 109, + 0, + 27, + 91, + 52, + 109, + 0, + 27, + 91, + 37, + 112, + 49, + 37, + 100, + 88, + 0, + 15, + 0, + 27, + 91, + 109, + 15, + 0, + 27, + 91, + 50, + 74, + 27, + 91, + 63, + 52, + 55, + 108, + 0, + 27, + 91, + 52, + 108, + 0, + 27, + 91, + 50, + 55, + 109, + 0, + 27, + 91, + 50, + 52, + 109, + 0, + 27, + 91, + 63, + 53, + 104, + 36, + 60, + 49, + 48, + 48, + 47, + 62, + 27, + 91, + 63, + 53, + 108, + 0, + 7, + 0, + 27, + 55, + 27, + 91, + 114, + 27, + 91, + 109, + 27, + 91, + 63, + 55, + 104, + 27, + 91, + 63, + 49, + 59, + 52, + 59, + 54, + 108, + 27, + 91, + 52, + 108, + 27, + 56, + 27, + 62, + 27, + 93, + 82, + 0, + 27, + 91, + 76, + 0, + 127, + 0, + 27, + 91, + 51, + 126, + 0, + 27, + 79, + 66, + 0, + 27, + 79, + 121, + 0, + 27, + 91, + 49, + 49, + 126, + 0, + 27, + 91, + 50, + 49, + 126, + 0, + 27, + 91, + 49, + 50, + 126, + 0, + 27, + 91, + 49, + 51, + 126, + 0, + 27, + 91, + 49, + 52, + 126, + 0, + 27, + 91, + 49, + 53, + 126, + 0, + 27, + 91, + 49, + 55, + 126, + 0, + 27, + 91, + 49, + 56, + 126, + 0, + 27, + 91, + 49, + 57, + 126, + 0, + 27, + 91, + 50, + 48, + 126, + 0, + 27, + 91, + 49, + 126, + 0, + 27, + 91, + 50, + 126, + 0, + 27, + 79, + 68, + 0, + 27, + 91, + 54, + 126, + 0, + 27, + 91, + 53, + 126, + 0, + 27, + 79, + 67, + 0, + 27, + 91, + 66, + 0, + 27, + 91, + 65, + 0, + 27, + 79, + 65, + 0, + 27, + 91, + 63, + 49, + 108, + 27, + 62, + 0, + 27, + 91, + 63, + 49, + 104, + 27, + 61, + 0, + 13, + 10, + 0, + 27, + 91, + 37, + 112, + 49, + 37, + 100, + 80, + 0, + 27, + 91, + 37, + 112, + 49, + 37, + 100, + 77, + 0, + 27, + 91, + 37, + 112, + 49, + 37, + 100, + 66, + 0, + 27, + 91, + 37, + 112, + 49, + 37, + 100, + 83, + 0, + 27, + 91, + 37, + 112, + 49, + 37, + 100, + 76, + 0, + 27, + 91, + 37, + 112, + 49, + 37, + 100, + 68, + 0, + 27, + 91, + 37, + 112, + 49, + 37, + 100, + 67, + 0, + 27, + 91, + 37, + 112, + 49, + 37, + 100, + 84, + 0, + 27, + 91, + 37, + 112, + 49, + 37, + 100, + 65, + 0, + 37, + 112, + 49, + 37, + 99, + 27, + 91, + 37, + 112, + 50, + 37, + 123, + 49, + 125, + 37, + 45, + 37, + 100, + 98, + 0, + 27, + 60, + 27, + 91, + 34, + 112, + 27, + 91, + 53, + 48, + 59, + 54, + 34, + 112, + 27, + 99, + 27, + 91, + 63, + 51, + 108, + 27, + 93, + 82, + 27, + 91, + 63, + 49, + 48, + 48, + 48, + 108, + 0, + 27, + 56, + 0, + 27, + 91, + 37, + 105, + 37, + 112, + 49, + 37, + 100, + 100, + 0, + 27, + 55, + 0, + 10, + 0, + 27, + 77, + 0, + 27, + 91, + 48, + 37, + 63, + 37, + 112, + 49, + 37, + 112, + 54, + 37, + 124, + 37, + 116, + 59, + 49, + 37, + 59, + 37, + 63, + 37, + 112, + 50, + 37, + 116, + 59, + 52, + 37, + 59, + 37, + 63, + 37, + 112, + 49, + 37, + 112, + 51, + 37, + 124, + 37, + 116, + 59, + 55, + 37, + 59, + 37, + 63, + 37, + 112, + 52, + 37, + 116, + 59, + 53, + 37, + 59, + 109, + 37, + 63, + 37, + 112, + 57, + 37, + 116, + 14, + 37, + 101, + 15, + 37, + 59, + 0, + 27, + 72, + 0, + 9, + 0, + 27, + 93, + 48, + 59, + 0, + 27, + 79, + 113, + 0, + 27, + 79, + 115, + 0, + 27, + 79, + 114, + 0, + 27, + 79, + 112, + 0, + 27, + 79, + 110, + 0, + 96, + 96, + 97, + 97, + 102, + 102, + 103, + 103, + 106, + 106, + 107, + 107, + 108, + 108, + 109, + 109, + 110, + 110, + 111, + 111, + 112, + 112, + 113, + 113, + 114, + 114, + 115, + 115, + 116, + 116, + 117, + 117, + 118, + 118, + 119, + 119, + 120, + 120, + 121, + 121, + 122, + 122, + 123, + 123, + 124, + 124, + 125, + 125, + 126, + 126, + 0, + 27, + 91, + 90, + 0, + 27, + 91, + 63, + 55, + 104, + 0, + 27, + 91, + 63, + 55, + 108, + 0, + 27, + 40, + 66, + 27, + 41, + 48, + 0, + 27, + 91, + 52, + 126, + 0, + 27, + 79, + 77, + 0, + 26, + 0, + 27, + 91, + 50, + 51, + 126, + 0, + 27, + 91, + 50, + 52, + 126, + 0, + 27, + 91, + 50, + 53, + 126, + 0, + 27, + 91, + 50, + 54, + 126, + 0, + 27, + 91, + 50, + 56, + 126, + 0, + 27, + 91, + 50, + 57, + 126, + 0, + 27, + 91, + 51, + 49, + 126, + 0, + 27, + 91, + 51, + 50, + 126, + 0, + 27, + 91, + 51, + 51, + 126, + 0, + 27, + 91, + 51, + 52, + 126, + 0, + 27, + 91, + 49, + 75, + 0, + 27, + 91, + 37, + 105, + 37, + 100, + 59, + 37, + 100, + 82, + 0, + 27, + 91, + 54, + 110, + 0, + 27, + 91, + 63, + 54, + 99, + 0, + 27, + 91, + 99, + 0, + 27, + 91, + 51, + 57, + 59, + 52, + 57, + 109, + 0, + 27, + 93, + 82, + 0, + 27, + 91, + 60, + 0, + 27, + 91, + 37, + 63, + 37, + 112, + 49, + 37, + 123, + 56, + 125, + 37, + 60, + 37, + 116, + 51, + 37, + 112, + 49, + 37, + 100, + 37, + 101, + 37, + 112, + 49, + 37, + 123, + 49, + 54, + 125, + 37, + 60, + 37, + 116, + 57, + 37, + 112, + 49, + 37, + 123, + 56, + 125, + 37, + 45, + 37, + 100, + 37, + 101, + 51, + 56, + 59, + 53, + 59, + 37, + 112, + 49, + 37, + 100, + 37, + 59, + 109, + 0, + 27, + 91, + 37, + 63, + 37, + 112, + 49, + 37, + 123, + 56, + 125, + 37, + 60, + 37, + 116, + 52, + 37, + 112, + 49, + 37, + 100, + 37, + 101, + 37, + 112, + 49, + 37, + 123, + 49, + 54, + 125, + 37, + 60, + 37, + 116, + 49, + 48, + 37, + 112, + 49, + 37, + 123, + 56, + 125, + 37, + 45, + 37, + 100, + 37, + 101, + 52, + 56, + 59, + 53, + 59, + 37, + 112, + 49, + 37, + 100, + 37, + 59, + 109, + 0, + 27, + 91, + 49, + 48, + 109, + 0, + 27, + 91, + 49, + 49, + 109, + 0, + 27, + 91, + 49, + 50, + 109, + 0, + 37, + 63, + 37, + 112, + 49, + 37, + 123, + 56, + 125, + 37, + 61, + 37, + 116, + 27, + 37, + 37, + 71, + @bitCast(i8, @truncate(i8, -@as(c_int, 30))), + @bitCast(i8, @truncate(i8, -@as(c_int, 105))), + @bitCast(i8, @truncate(i8, -@as(c_int, 104))), + 27, + 37, + 37, + 64, + 37, + 101, + 37, + 112, + 49, + 37, + 123, + 49, + 48, + 125, + 37, + 61, + 37, + 116, + 27, + 37, + 37, + 71, + @bitCast(i8, @truncate(i8, -@as(c_int, 30))), + @bitCast(i8, @truncate(i8, -@as(c_int, 105))), + @bitCast(i8, @truncate(i8, -@as(c_int, 103))), + 27, + 37, + 37, + 64, + 37, + 101, + 37, + 112, + 49, + 37, + 123, + 49, + 50, + 125, + 37, + 61, + 37, + 116, + 27, + 37, + 37, + 71, + @bitCast(i8, @truncate(i8, -@as(c_int, 30))), + @bitCast(i8, @truncate(i8, -@as(c_int, 103))), + @bitCast(i8, @truncate(i8, -@as(c_int, 128))), + 27, + 37, + 37, + 64, + 37, + 101, + 37, + 112, + 49, + 37, + 123, + 49, + 51, + 125, + 37, + 61, + 37, + 116, + 27, + 37, + 37, + 71, + @bitCast(i8, @truncate(i8, -@as(c_int, 30))), + @bitCast(i8, @truncate(i8, -@as(c_int, 103))), + @bitCast(i8, @truncate(i8, -@as(c_int, 86))), + 27, + 37, + 37, + 64, + 37, + 101, + 37, + 112, + 49, + 37, + 123, + 49, + 52, + 125, + 37, + 61, + 37, + 116, + 27, + 37, + 37, + 71, + @bitCast(i8, @truncate(i8, -@as(c_int, 30))), + @bitCast(i8, @truncate(i8, -@as(c_int, 103))), + @bitCast(i8, @truncate(i8, -@as(c_int, 85))), + 27, + 37, + 37, + 64, + 37, + 101, + 37, + 112, + 49, + 37, + 123, + 49, + 53, + 125, + 37, + 61, + 37, + 116, + 27, + 37, + 37, + 71, + @bitCast(i8, @truncate(i8, -@as(c_int, 30))), + @bitCast(i8, @truncate(i8, -@as(c_int, 104))), + @bitCast(i8, @truncate(i8, -@as(c_int, 68))), + 27, + 37, + 37, + 64, + 37, + 101, + 37, + 112, + 49, + 37, + 123, + 50, + 55, + 125, + 37, + 61, + 37, + 116, + 27, + 37, + 37, + 71, + @bitCast(i8, @truncate(i8, -@as(c_int, 30))), + @bitCast(i8, @truncate(i8, -@as(c_int, 122))), + @bitCast(i8, @truncate(i8, -@as(c_int, 112))), + 27, + 37, + 37, + 64, + 37, + 101, + 37, + 112, + 49, + 37, + 123, + 49, + 53, + 53, + 125, + 37, + 61, + 37, + 116, + 27, + 37, + 37, + 71, + @bitCast(i8, @truncate(i8, -@as(c_int, 32))), + @bitCast(i8, @truncate(i8, -@as(c_int, 126))), + @bitCast(i8, @truncate(i8, -@as(c_int, 94))), + 27, + 37, + 37, + 64, + 37, + 101, + 37, + 112, + 49, + 37, + 99, + 37, + 59, + 0, + 27, + 91, + 49, + 49, + 109, + 0, + 27, + 91, + 49, + 48, + 109, + 0, + 1, + 0, + 1, + 0, + 20, + 0, + 42, + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 17))), + 0, + 1, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 5, + 0, + 10, + 0, + 42, + 0, + 46, + 0, + 50, + 0, + 54, + 0, + 58, + 0, + 62, + 0, + 66, + 0, + 70, + 0, + 74, + 0, + 78, + 0, + 82, + 0, + 86, + 0, + 90, + 0, + 94, + 0, + 98, + 0, + 102, + 0, + 106, + 0, + 0, + 0, + 3, + 0, + 6, + 0, + 9, + 0, + 12, + 0, + 15, + 0, + 19, + 0, + 23, + 0, + 27, + 0, + 31, + 0, + 35, + 0, + 39, + 0, + 43, + 0, + 47, + 0, + 51, + 0, + 57, + 0, + 63, + 0, + 69, + 0, + 75, + 0, + 81, + 0, + 87, + 0, + 93, + 0, + 27, + 91, + 51, + 74, + 0, + 27, + 93, + 48, + 59, + 0, + 27, + 91, + 63, + 49, + 48, + 48, + 54, + 59, + 49, + 48, + 48, + 48, + 37, + 63, + 37, + 112, + 49, + 37, + 123, + 49, + 125, + 37, + 61, + 37, + 116, + 104, + 37, + 101, + 108, + 37, + 59, + 0, + 27, + 79, + 113, + 0, + 27, + 79, + 114, + 0, + 27, + 79, + 115, + 0, + 27, + 79, + 116, + 0, + 27, + 79, + 117, + 0, + 27, + 79, + 118, + 0, + 27, + 79, + 119, + 0, + 27, + 79, + 120, + 0, + 27, + 79, + 121, + 0, + 27, + 79, + 108, + 0, + 27, + 79, + 81, + 0, + 27, + 79, + 110, + 0, + 27, + 79, + 82, + 0, + 27, + 79, + 80, + 0, + 27, + 79, + 83, + 0, + 27, + 79, + 112, + 0, + 27, + 91, + 60, + 37, + 105, + 37, + 112, + 51, + 37, + 100, + 59, + 37, + 112, + 49, + 37, + 100, + 59, + 37, + 112, + 50, + 37, + 100, + 59, + 37, + 63, + 37, + 112, + 52, + 37, + 116, + 77, + 37, + 101, + 109, + 37, + 59, + 0, + 88, + 84, + 0, + 85, + 56, + 0, + 69, + 51, + 0, + 84, + 83, + 0, + 88, + 77, + 0, + 107, + 112, + 49, + 0, + 107, + 112, + 50, + 0, + 107, + 112, + 51, + 0, + 107, + 112, + 52, + 0, + 107, + 112, + 53, + 0, + 107, + 112, + 54, + 0, + 107, + 112, + 55, + 0, + 107, + 112, + 56, + 0, + 107, + 112, + 57, + 0, + 107, + 112, + 65, + 68, + 68, + 0, + 107, + 112, + 68, + 73, + 86, + 0, + 107, + 112, + 68, + 79, + 84, + 0, + 107, + 112, + 77, + 85, + 76, + 0, + 107, + 112, + 78, + 85, + 77, + 0, + 107, + 112, + 83, + 85, + 66, + 0, + 107, + 112, + 90, + 82, + 79, + 0, + 120, + 109, + 0, +}; +pub const rxvt_256colour_terminfo: [2460]i8 = [2460]i8{ + 30, + 2, + 47, + 0, + 38, + 0, + 15, + 0, + 110, + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 35))), + 4, + 114, + 120, + 118, + 116, + 45, + 50, + 53, + 54, + 99, + 111, + 108, + 111, + 114, + 124, + 114, + 120, + 118, + 116, + 32, + 50, + 46, + 55, + 46, + 57, + 32, + 119, + 105, + 116, + 104, + 32, + 120, + 116, + 101, + 114, + 109, + 32, + 50, + 53, + 54, + 45, + 99, + 111, + 108, + 111, + 114, + 115, + 0, + 0, + 1, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 80, + 0, + 0, + 0, + 8, + 0, + 0, + 0, + 24, + 0, + 0, + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 0, + 1, + 0, + 0, + 0, + 0, + 1, + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 0, + 0, + 2, + 0, + 4, + 0, + 21, + 0, + 26, + 0, + 34, + 0, + 38, + 0, + 42, + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 53, + 0, + 70, + 0, + 72, + 0, + 76, + 0, + 83, + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 85, + 0, + 92, + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 96, + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 100, + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 104, + 0, + 106, + 0, + 111, + 0, + 116, + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 125, + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 126))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 121))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 116))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 111))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 109))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 104))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 91))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 86))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 80))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 74))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 56))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 42))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 8))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 4))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 3, + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 7, + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 12, + 1, + 18, + 1, + 24, + 1, + 30, + 1, + 36, + 1, + 42, + 1, + 48, + 1, + 54, + 1, + 60, + 1, + 66, + 1, + 72, + 1, + 78, + 1, + 83, + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 88, + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 92, + 1, + 97, + 1, + 102, + 1, + 106, + 1, + 110, + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 114, + 1, + 118, + 1, + 121, + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 124, + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 123))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 114))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 105))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 96))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 87))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 78))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 69))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 36))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 14, + 2, + 17, + 2, + 28, + 2, + 31, + 2, + 33, + 2, + 36, + 2, + 103, + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 106, + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 108, + 2, + 112, + 2, + 116, + 2, + 120, + 2, + 124, + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 128))), + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 77))), + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 73))), + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 66))), + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 61))), + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 57))), + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 52))), + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 47))), + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 42))), + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 37))), + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 32))), + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 27))), + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 23))), + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 18))), + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 13))), + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 9))), + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 3))), + 2, + 3, + 3, + 9, + 3, + 15, + 3, + 21, + 3, + 27, + 3, + 33, + 3, + 39, + 3, + 45, + 3, + 51, + 3, + 57, + 3, + 63, + 3, + 69, + 3, + 75, + 3, + 81, + 3, + 87, + 3, + 93, + 3, + 99, + 3, + 105, + 3, + 111, + 3, + 117, + 3, + 123, + 3, + @bitCast(i8, @truncate(i8, -@as(c_int, 127))), + 3, + @bitCast(i8, @truncate(i8, -@as(c_int, 121))), + 3, + @bitCast(i8, @truncate(i8, -@as(c_int, 115))), + 3, + @bitCast(i8, @truncate(i8, -@as(c_int, 109))), + 3, + @bitCast(i8, @truncate(i8, -@as(c_int, 103))), + 3, + @bitCast(i8, @truncate(i8, -@as(c_int, 97))), + 3, + @bitCast(i8, @truncate(i8, -@as(c_int, 91))), + 3, + @bitCast(i8, @truncate(i8, -@as(c_int, 85))), + 3, + @bitCast(i8, @truncate(i8, -@as(c_int, 79))), + 3, + @bitCast(i8, @truncate(i8, -@as(c_int, 73))), + 3, + @bitCast(i8, @truncate(i8, -@as(c_int, 67))), + 3, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 61))), + 3, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 56))), + 3, + @bitCast(i8, @truncate(i8, -@as(c_int, 45))), + 3, + @bitCast(i8, @truncate(i8, -@as(c_int, 40))), + 3, + @bitCast(i8, @truncate(i8, -@as(c_int, 32))), + 3, + @bitCast(i8, @truncate(i8, -@as(c_int, 28))), + 3, + @bitCast(i8, @truncate(i8, -@as(c_int, 19))), + 3, + @bitCast(i8, @truncate(i8, -@as(c_int, 12))), + 3, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 82, + 4, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 86, + 4, + @bitCast(i8, @truncate(i8, -@as(c_int, 107))), + 4, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 43))), + 4, + @bitCast(i8, @truncate(i8, -@as(c_int, 39))), + 4, + 7, + 0, + 13, + 0, + 27, + 91, + 37, + 105, + 37, + 112, + 49, + 37, + 100, + 59, + 37, + 112, + 50, + 37, + 100, + 114, + 0, + 27, + 91, + 51, + 103, + 0, + 27, + 91, + 72, + 27, + 91, + 50, + 74, + 0, + 27, + 91, + 75, + 0, + 27, + 91, + 74, + 0, + 27, + 91, + 37, + 105, + 37, + 112, + 49, + 37, + 100, + 71, + 0, + 27, + 91, + 37, + 105, + 37, + 112, + 49, + 37, + 100, + 59, + 37, + 112, + 50, + 37, + 100, + 72, + 0, + 10, + 0, + 27, + 91, + 72, + 0, + 27, + 91, + 63, + 50, + 53, + 108, + 0, + 8, + 0, + 27, + 91, + 63, + 50, + 53, + 104, + 0, + 27, + 91, + 67, + 0, + 27, + 91, + 65, + 0, + 27, + 91, + 77, + 0, + 14, + 0, + 27, + 91, + 53, + 109, + 0, + 27, + 91, + 49, + 109, + 0, + 27, + 55, + 27, + 91, + 63, + 52, + 55, + 104, + 0, + 27, + 91, + 52, + 104, + 0, + 27, + 91, + 55, + 109, + 0, + 27, + 91, + 55, + 109, + 0, + 27, + 91, + 52, + 109, + 0, + 15, + 0, + 27, + 91, + 109, + 15, + 0, + 27, + 91, + 50, + 74, + 27, + 91, + 63, + 52, + 55, + 108, + 27, + 56, + 0, + 27, + 91, + 52, + 108, + 0, + 27, + 91, + 50, + 55, + 109, + 0, + 27, + 91, + 50, + 52, + 109, + 0, + 27, + 91, + 63, + 53, + 104, + 36, + 60, + 49, + 48, + 48, + 47, + 62, + 27, + 91, + 63, + 53, + 108, + 0, + 27, + 91, + 63, + 52, + 55, + 108, + 27, + 61, + 27, + 91, + 63, + 49, + 108, + 0, + 27, + 91, + 114, + 27, + 91, + 109, + 27, + 91, + 50, + 74, + 27, + 91, + 72, + 27, + 91, + 63, + 55, + 104, + 27, + 91, + 63, + 49, + 59, + 51, + 59, + 52, + 59, + 54, + 108, + 27, + 91, + 52, + 108, + 0, + 27, + 91, + 76, + 0, + 8, + 0, + 27, + 91, + 51, + 126, + 0, + 27, + 91, + 66, + 0, + 27, + 91, + 56, + 94, + 0, + 27, + 91, + 50, + 49, + 126, + 0, + 27, + 91, + 49, + 49, + 126, + 0, + 27, + 91, + 50, + 49, + 126, + 0, + 27, + 91, + 49, + 50, + 126, + 0, + 27, + 91, + 49, + 51, + 126, + 0, + 27, + 91, + 49, + 52, + 126, + 0, + 27, + 91, + 49, + 53, + 126, + 0, + 27, + 91, + 49, + 55, + 126, + 0, + 27, + 91, + 49, + 56, + 126, + 0, + 27, + 91, + 49, + 57, + 126, + 0, + 27, + 91, + 50, + 48, + 126, + 0, + 27, + 91, + 55, + 126, + 0, + 27, + 91, + 50, + 126, + 0, + 27, + 91, + 68, + 0, + 27, + 91, + 54, + 126, + 0, + 27, + 91, + 53, + 126, + 0, + 27, + 91, + 67, + 0, + 27, + 91, + 97, + 0, + 27, + 91, + 98, + 0, + 27, + 91, + 65, + 0, + 27, + 62, + 0, + 27, + 61, + 0, + 27, + 91, + 37, + 112, + 49, + 37, + 100, + 77, + 0, + 27, + 91, + 37, + 112, + 49, + 37, + 100, + 66, + 0, + 27, + 91, + 37, + 112, + 49, + 37, + 100, + 64, + 0, + 27, + 91, + 37, + 112, + 49, + 37, + 100, + 76, + 0, + 27, + 91, + 37, + 112, + 49, + 37, + 100, + 68, + 0, + 27, + 91, + 37, + 112, + 49, + 37, + 100, + 67, + 0, + 27, + 91, + 37, + 112, + 49, + 37, + 100, + 65, + 0, + 27, + 62, + 27, + 91, + 49, + 59, + 51, + 59, + 52, + 59, + 53, + 59, + 54, + 108, + 27, + 91, + 63, + 55, + 104, + 27, + 91, + 109, + 27, + 91, + 114, + 27, + 91, + 50, + 74, + 27, + 91, + 72, + 0, + 27, + 91, + 114, + 27, + 91, + 109, + 27, + 91, + 50, + 74, + 27, + 91, + 72, + 27, + 91, + 63, + 55, + 104, + 27, + 91, + 63, + 49, + 59, + 51, + 59, + 52, + 59, + 54, + 108, + 27, + 91, + 52, + 108, + 27, + 62, + 27, + 91, + 63, + 49, + 48, + 48, + 48, + 108, + 27, + 91, + 63, + 50, + 53, + 104, + 0, + 27, + 56, + 0, + 27, + 91, + 37, + 105, + 37, + 112, + 49, + 37, + 100, + 100, + 0, + 27, + 55, + 0, + 10, + 0, + 27, + 77, + 0, + 27, + 91, + 48, + 37, + 63, + 37, + 112, + 54, + 37, + 116, + 59, + 49, + 37, + 59, + 37, + 63, + 37, + 112, + 50, + 37, + 116, + 59, + 52, + 37, + 59, + 37, + 63, + 37, + 112, + 49, + 37, + 112, + 51, + 37, + 124, + 37, + 116, + 59, + 55, + 37, + 59, + 37, + 63, + 37, + 112, + 52, + 37, + 116, + 59, + 53, + 37, + 59, + 109, + 37, + 63, + 37, + 112, + 57, + 37, + 116, + 14, + 37, + 101, + 15, + 37, + 59, + 0, + 27, + 72, + 0, + 9, + 0, + 27, + 79, + 119, + 0, + 27, + 79, + 121, + 0, + 27, + 79, + 117, + 0, + 27, + 79, + 113, + 0, + 27, + 79, + 115, + 0, + 96, + 96, + 97, + 97, + 102, + 102, + 103, + 103, + 106, + 106, + 107, + 107, + 108, + 108, + 109, + 109, + 110, + 110, + 111, + 111, + 112, + 112, + 113, + 113, + 114, + 114, + 115, + 115, + 116, + 116, + 117, + 117, + 118, + 118, + 119, + 119, + 120, + 120, + 121, + 121, + 122, + 122, + 123, + 123, + 124, + 124, + 125, + 125, + 126, + 126, + 0, + 27, + 91, + 90, + 0, + 27, + 40, + 66, + 27, + 41, + 48, + 0, + 27, + 91, + 56, + 126, + 0, + 27, + 79, + 77, + 0, + 27, + 91, + 49, + 126, + 0, + 27, + 91, + 51, + 36, + 0, + 27, + 91, + 52, + 126, + 0, + 27, + 91, + 56, + 36, + 0, + 27, + 91, + 55, + 36, + 0, + 27, + 91, + 50, + 36, + 0, + 27, + 91, + 100, + 0, + 27, + 91, + 54, + 36, + 0, + 27, + 91, + 53, + 36, + 0, + 27, + 91, + 99, + 0, + 27, + 91, + 50, + 51, + 126, + 0, + 27, + 91, + 50, + 52, + 126, + 0, + 27, + 91, + 50, + 53, + 126, + 0, + 27, + 91, + 50, + 54, + 126, + 0, + 27, + 91, + 50, + 56, + 126, + 0, + 27, + 91, + 50, + 57, + 126, + 0, + 27, + 91, + 51, + 49, + 126, + 0, + 27, + 91, + 51, + 50, + 126, + 0, + 27, + 91, + 51, + 51, + 126, + 0, + 27, + 91, + 51, + 52, + 126, + 0, + 27, + 91, + 50, + 51, + 36, + 0, + 27, + 91, + 50, + 52, + 36, + 0, + 27, + 91, + 49, + 49, + 94, + 0, + 27, + 91, + 49, + 50, + 94, + 0, + 27, + 91, + 49, + 51, + 94, + 0, + 27, + 91, + 49, + 52, + 94, + 0, + 27, + 91, + 49, + 53, + 94, + 0, + 27, + 91, + 49, + 55, + 94, + 0, + 27, + 91, + 49, + 56, + 94, + 0, + 27, + 91, + 49, + 57, + 94, + 0, + 27, + 91, + 50, + 48, + 94, + 0, + 27, + 91, + 50, + 49, + 94, + 0, + 27, + 91, + 50, + 51, + 94, + 0, + 27, + 91, + 50, + 52, + 94, + 0, + 27, + 91, + 50, + 53, + 94, + 0, + 27, + 91, + 50, + 54, + 94, + 0, + 27, + 91, + 50, + 56, + 94, + 0, + 27, + 91, + 50, + 57, + 94, + 0, + 27, + 91, + 51, + 49, + 94, + 0, + 27, + 91, + 51, + 50, + 94, + 0, + 27, + 91, + 51, + 51, + 94, + 0, + 27, + 91, + 51, + 52, + 94, + 0, + 27, + 91, + 50, + 51, + 64, + 0, + 27, + 91, + 50, + 52, + 64, + 0, + 27, + 91, + 49, + 75, + 0, + 27, + 91, + 37, + 105, + 37, + 100, + 59, + 37, + 100, + 82, + 0, + 27, + 91, + 54, + 110, + 0, + 27, + 91, + 63, + 49, + 59, + 50, + 99, + 0, + 27, + 91, + 99, + 0, + 27, + 91, + 51, + 57, + 59, + 52, + 57, + 109, + 0, + 27, + 93, + 49, + 48, + 52, + 7, + 0, + 27, + 93, + 52, + 59, + 37, + 112, + 49, + 37, + 100, + 59, + 114, + 103, + 98, + 58, + 37, + 112, + 50, + 37, + 123, + 50, + 53, + 53, + 125, + 37, + 42, + 37, + 123, + 49, + 48, + 48, + 48, + 125, + 37, + 47, + 37, + 50, + 46, + 50, + 88, + 47, + 37, + 112, + 51, + 37, + 123, + 50, + 53, + 53, + 125, + 37, + 42, + 37, + 123, + 49, + 48, + 48, + 48, + 125, + 37, + 47, + 37, + 50, + 46, + 50, + 88, + 47, + 37, + 112, + 52, + 37, + 123, + 50, + 53, + 53, + 125, + 37, + 42, + 37, + 123, + 49, + 48, + 48, + 48, + 125, + 37, + 47, + 37, + 50, + 46, + 50, + 88, + 27, + 92, + 0, + 27, + 91, + 77, + 0, + 27, + 91, + 37, + 63, + 37, + 112, + 49, + 37, + 123, + 56, + 125, + 37, + 60, + 37, + 116, + 51, + 37, + 112, + 49, + 37, + 100, + 37, + 101, + 37, + 112, + 49, + 37, + 123, + 49, + 54, + 125, + 37, + 60, + 37, + 116, + 57, + 37, + 112, + 49, + 37, + 123, + 56, + 125, + 37, + 45, + 37, + 100, + 37, + 101, + 51, + 56, + 59, + 53, + 59, + 37, + 112, + 49, + 37, + 100, + 37, + 59, + 109, + 0, + 27, + 91, + 37, + 63, + 37, + 112, + 49, + 37, + 123, + 56, + 125, + 37, + 60, + 37, + 116, + 52, + 37, + 112, + 49, + 37, + 100, + 37, + 101, + 37, + 112, + 49, + 37, + 123, + 49, + 54, + 125, + 37, + 60, + 37, + 116, + 49, + 48, + 37, + 112, + 49, + 37, + 123, + 56, + 125, + 37, + 45, + 37, + 100, + 37, + 101, + 52, + 56, + 59, + 53, + 59, + 37, + 112, + 49, + 37, + 100, + 37, + 59, + 109, + 0, + 27, + 40, + 66, + 0, + 27, + 40, + 48, + 0, + 0, + 2, + 0, + 0, + 0, + 22, + 0, + 46, + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 36))), + 0, + 1, + 1, + 0, + 0, + 5, + 0, + 10, + 0, + 14, + 0, + 18, + 0, + 23, + 0, + 28, + 0, + 33, + 0, + 38, + 0, + 43, + 0, + 48, + 0, + 52, + 0, + 57, + 0, + 62, + 0, + 67, + 0, + 72, + 0, + 76, + 0, + 80, + 0, + 84, + 0, + 88, + 0, + 92, + 0, + 96, + 0, + 0, + 0, + 3, + 0, + 6, + 0, + 11, + 0, + 16, + 0, + 20, + 0, + 25, + 0, + 31, + 0, + 37, + 0, + 43, + 0, + 49, + 0, + 54, + 0, + 59, + 0, + 65, + 0, + 71, + 0, + 77, + 0, + 83, + 0, + 89, + 0, + 95, + 0, + 99, + 0, + 104, + 0, + 108, + 0, + 112, + 0, + 116, + 0, + 27, + 91, + 51, + 94, + 0, + 27, + 91, + 51, + 64, + 0, + 27, + 91, + 98, + 0, + 27, + 79, + 98, + 0, + 27, + 91, + 56, + 94, + 0, + 27, + 91, + 56, + 64, + 0, + 27, + 91, + 55, + 94, + 0, + 27, + 91, + 55, + 64, + 0, + 27, + 91, + 50, + 94, + 0, + 27, + 91, + 50, + 64, + 0, + 27, + 79, + 100, + 0, + 27, + 91, + 54, + 94, + 0, + 27, + 91, + 54, + 64, + 0, + 27, + 91, + 53, + 94, + 0, + 27, + 91, + 53, + 64, + 0, + 27, + 79, + 99, + 0, + 27, + 91, + 97, + 0, + 27, + 79, + 97, + 0, + 27, + 79, + 120, + 0, + 27, + 79, + 116, + 0, + 27, + 79, + 118, + 0, + 27, + 79, + 114, + 0, + 65, + 88, + 0, + 88, + 84, + 0, + 107, + 68, + 67, + 53, + 0, + 107, + 68, + 67, + 54, + 0, + 107, + 68, + 78, + 0, + 107, + 68, + 78, + 53, + 0, + 107, + 69, + 78, + 68, + 53, + 0, + 107, + 69, + 78, + 68, + 54, + 0, + 107, + 72, + 79, + 77, + 53, + 0, + 107, + 72, + 79, + 77, + 54, + 0, + 107, + 73, + 67, + 53, + 0, + 107, + 73, + 67, + 54, + 0, + 107, + 76, + 70, + 84, + 53, + 0, + 107, + 78, + 88, + 84, + 53, + 0, + 107, + 78, + 88, + 84, + 54, + 0, + 107, + 80, + 82, + 86, + 53, + 0, + 107, + 80, + 82, + 86, + 54, + 0, + 107, + 82, + 73, + 84, + 53, + 0, + 107, + 85, + 80, + 0, + 107, + 85, + 80, + 53, + 0, + 107, + 97, + 50, + 0, + 107, + 98, + 49, + 0, + 107, + 98, + 51, + 0, + 107, + 99, + 50, + 0, +}; +pub const screen_256colour_terminfo: [1747]i8 = [1747]i8{ + 30, + 2, + 43, + 0, + 43, + 0, + 15, + 0, + 105, + 1, + 41, + 3, + 115, + 99, + 114, + 101, + 101, + 110, + 45, + 50, + 53, + 54, + 99, + 111, + 108, + 111, + 114, + 124, + 71, + 78, + 85, + 32, + 83, + 99, + 114, + 101, + 101, + 110, + 32, + 119, + 105, + 116, + 104, + 32, + 50, + 53, + 54, + 32, + 99, + 111, + 108, + 111, + 114, + 115, + 0, + 0, + 1, + 0, + 0, + 1, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 1, + 80, + 0, + 0, + 0, + 8, + 0, + 0, + 0, + 24, + 0, + 0, + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 0, + 1, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 4, + 0, + 6, + 0, + 8, + 0, + 25, + 0, + 30, + 0, + 37, + 0, + 41, + 0, + 45, + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 56, + 0, + 73, + 0, + 75, + 0, + 79, + 0, + 86, + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 88, + 0, + 100, + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 104, + 0, + 107, + 0, + 113, + 0, + 117, + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 121, + 0, + 123, + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 128))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 123))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 114))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 109))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 104))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 99))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 94))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 89))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 87))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 82))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 73))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 68))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 62))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 56))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 53))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 49))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 45))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 43))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 38))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 34))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 30))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 24))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 20))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 16))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 12))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 6))), + 0, + 0, + 1, + 6, + 1, + 12, + 1, + 18, + 1, + 23, + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 28, + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 32, + 1, + 37, + 1, + 42, + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 46, + 1, + 50, + 1, + 58, + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 66, + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 69, + 1, + 78, + 1, + 87, + 1, + 96, + 1, + 105, + 1, + 114, + 1, + 123, + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 124))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 115))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 106))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 97))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 80))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 77))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 66))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 63))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 61))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 58))), + 1, + 26, + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 29, + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 31, + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 96, + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 100, + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 107, + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 112, + 2, + 118, + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 124, + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 127))), + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 116))), + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 111))), + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 103))), + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 99))), + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 90))), + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 86))), + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 23))), + 2, + 27, + 91, + 90, + 0, + 7, + 0, + 13, + 0, + 27, + 91, + 37, + 105, + 37, + 112, + 49, + 37, + 100, + 59, + 37, + 112, + 50, + 37, + 100, + 114, + 0, + 27, + 91, + 51, + 103, + 0, + 27, + 91, + 72, + 27, + 91, + 74, + 0, + 27, + 91, + 75, + 0, + 27, + 91, + 74, + 0, + 27, + 91, + 37, + 105, + 37, + 112, + 49, + 37, + 100, + 71, + 0, + 27, + 91, + 37, + 105, + 37, + 112, + 49, + 37, + 100, + 59, + 37, + 112, + 50, + 37, + 100, + 72, + 0, + 10, + 0, + 27, + 91, + 72, + 0, + 27, + 91, + 63, + 50, + 53, + 108, + 0, + 8, + 0, + 27, + 91, + 51, + 52, + 104, + 27, + 91, + 63, + 50, + 53, + 104, + 0, + 27, + 91, + 67, + 0, + 27, + 77, + 0, + 27, + 91, + 51, + 52, + 108, + 0, + 27, + 91, + 80, + 0, + 27, + 91, + 77, + 0, + 14, + 0, + 27, + 91, + 53, + 109, + 0, + 27, + 91, + 49, + 109, + 0, + 27, + 91, + 63, + 49, + 48, + 52, + 57, + 104, + 0, + 27, + 91, + 50, + 109, + 0, + 27, + 91, + 52, + 104, + 0, + 27, + 91, + 55, + 109, + 0, + 27, + 91, + 51, + 109, + 0, + 27, + 91, + 52, + 109, + 0, + 15, + 0, + 27, + 91, + 109, + 15, + 0, + 27, + 91, + 63, + 49, + 48, + 52, + 57, + 108, + 0, + 27, + 91, + 52, + 108, + 0, + 27, + 91, + 50, + 51, + 109, + 0, + 27, + 91, + 50, + 52, + 109, + 0, + 27, + 103, + 0, + 27, + 41, + 48, + 0, + 27, + 91, + 76, + 0, + 8, + 0, + 27, + 91, + 51, + 126, + 0, + 27, + 79, + 66, + 0, + 27, + 79, + 80, + 0, + 27, + 91, + 50, + 49, + 126, + 0, + 27, + 79, + 81, + 0, + 27, + 79, + 82, + 0, + 27, + 79, + 83, + 0, + 27, + 91, + 49, + 53, + 126, + 0, + 27, + 91, + 49, + 55, + 126, + 0, + 27, + 91, + 49, + 56, + 126, + 0, + 27, + 91, + 49, + 57, + 126, + 0, + 27, + 91, + 50, + 48, + 126, + 0, + 27, + 91, + 49, + 126, + 0, + 27, + 91, + 50, + 126, + 0, + 27, + 79, + 68, + 0, + 27, + 91, + 54, + 126, + 0, + 27, + 91, + 53, + 126, + 0, + 27, + 79, + 67, + 0, + 27, + 79, + 65, + 0, + 27, + 91, + 63, + 49, + 108, + 27, + 62, + 0, + 27, + 91, + 63, + 49, + 104, + 27, + 61, + 0, + 27, + 69, + 0, + 27, + 91, + 37, + 112, + 49, + 37, + 100, + 80, + 0, + 27, + 91, + 37, + 112, + 49, + 37, + 100, + 77, + 0, + 27, + 91, + 37, + 112, + 49, + 37, + 100, + 66, + 0, + 27, + 91, + 37, + 112, + 49, + 37, + 100, + 64, + 0, + 27, + 91, + 37, + 112, + 49, + 37, + 100, + 83, + 0, + 27, + 91, + 37, + 112, + 49, + 37, + 100, + 76, + 0, + 27, + 91, + 37, + 112, + 49, + 37, + 100, + 68, + 0, + 27, + 91, + 37, + 112, + 49, + 37, + 100, + 67, + 0, + 27, + 91, + 37, + 112, + 49, + 37, + 100, + 84, + 0, + 27, + 91, + 37, + 112, + 49, + 37, + 100, + 65, + 0, + 27, + 99, + 27, + 91, + 63, + 49, + 48, + 48, + 48, + 108, + 27, + 91, + 63, + 50, + 53, + 104, + 0, + 27, + 56, + 0, + 27, + 91, + 37, + 105, + 37, + 112, + 49, + 37, + 100, + 100, + 0, + 27, + 55, + 0, + 10, + 0, + 27, + 77, + 0, + 27, + 91, + 48, + 37, + 63, + 37, + 112, + 54, + 37, + 116, + 59, + 49, + 37, + 59, + 37, + 63, + 37, + 112, + 49, + 37, + 116, + 59, + 51, + 37, + 59, + 37, + 63, + 37, + 112, + 50, + 37, + 116, + 59, + 52, + 37, + 59, + 37, + 63, + 37, + 112, + 51, + 37, + 116, + 59, + 55, + 37, + 59, + 37, + 63, + 37, + 112, + 52, + 37, + 116, + 59, + 53, + 37, + 59, + 37, + 63, + 37, + 112, + 53, + 37, + 116, + 59, + 50, + 37, + 59, + 109, + 37, + 63, + 37, + 112, + 57, + 37, + 116, + 14, + 37, + 101, + 15, + 37, + 59, + 0, + 27, + 72, + 0, + 9, + 0, + 43, + 43, + 44, + 44, + 45, + 45, + 46, + 46, + 48, + 48, + 96, + 96, + 97, + 97, + 102, + 102, + 103, + 103, + 104, + 104, + 105, + 105, + 106, + 106, + 107, + 107, + 108, + 108, + 109, + 109, + 110, + 110, + 111, + 111, + 112, + 112, + 113, + 113, + 114, + 114, + 115, + 115, + 116, + 116, + 117, + 117, + 118, + 118, + 119, + 119, + 120, + 120, + 121, + 121, + 122, + 122, + 123, + 123, + 124, + 124, + 125, + 125, + 126, + 126, + 0, + 27, + 91, + 90, + 0, + 27, + 40, + 66, + 27, + 41, + 48, + 0, + 27, + 91, + 52, + 126, + 0, + 27, + 91, + 50, + 51, + 126, + 0, + 27, + 91, + 50, + 52, + 126, + 0, + 27, + 91, + 49, + 75, + 0, + 27, + 91, + 37, + 105, + 37, + 100, + 59, + 37, + 100, + 82, + 0, + 27, + 91, + 54, + 110, + 0, + 27, + 91, + 63, + 49, + 59, + 50, + 99, + 0, + 27, + 91, + 99, + 0, + 27, + 91, + 51, + 57, + 59, + 52, + 57, + 109, + 0, + 27, + 91, + 77, + 0, + 27, + 91, + 37, + 63, + 37, + 112, + 49, + 37, + 123, + 56, + 125, + 37, + 60, + 37, + 116, + 51, + 37, + 112, + 49, + 37, + 100, + 37, + 101, + 37, + 112, + 49, + 37, + 123, + 49, + 54, + 125, + 37, + 60, + 37, + 116, + 57, + 37, + 112, + 49, + 37, + 123, + 56, + 125, + 37, + 45, + 37, + 100, + 37, + 101, + 51, + 56, + 59, + 53, + 59, + 37, + 112, + 49, + 37, + 100, + 37, + 59, + 109, + 0, + 27, + 91, + 37, + 63, + 37, + 112, + 49, + 37, + 123, + 56, + 125, + 37, + 60, + 37, + 116, + 52, + 37, + 112, + 49, + 37, + 100, + 37, + 101, + 37, + 112, + 49, + 37, + 123, + 49, + 54, + 125, + 37, + 60, + 37, + 116, + 49, + 48, + 37, + 112, + 49, + 37, + 123, + 56, + 125, + 37, + 45, + 37, + 100, + 37, + 101, + 52, + 56, + 59, + 53, + 59, + 37, + 112, + 49, + 37, + 100, + 37, + 59, + 109, + 0, + 0, + 2, + 0, + 1, + 0, + 2, + 0, + 7, + 0, + 27, + 0, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 4, + 0, + 0, + 0, + 3, + 0, + 6, + 0, + 9, + 0, + 12, + 0, + 27, + 40, + 66, + 0, + 27, + 40, + 37, + 112, + 49, + 37, + 99, + 0, + 65, + 88, + 0, + 71, + 48, + 0, + 85, + 56, + 0, + 69, + 48, + 0, + 83, + 48, + 0, +}; +pub const st_256colour_terminfo: [2699]i8 = [2699]i8{ + 30, + 2, + 55, + 0, + 29, + 0, + 15, + 0, + 105, + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 28))), + 5, + 115, + 116, + 45, + 50, + 53, + 54, + 99, + 111, + 108, + 111, + 114, + 124, + 115, + 116, + 116, + 101, + 114, + 109, + 45, + 50, + 53, + 54, + 99, + 111, + 108, + 111, + 114, + 124, + 115, + 105, + 109, + 112, + 108, + 101, + 116, + 101, + 114, + 109, + 32, + 119, + 105, + 116, + 104, + 32, + 50, + 53, + 54, + 32, + 99, + 111, + 108, + 111, + 114, + 115, + 0, + 0, + 1, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 1, + 1, + 80, + 0, + 0, + 0, + 8, + 0, + 0, + 0, + 24, + 0, + 0, + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 0, + 1, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 4, + 0, + 6, + 0, + 8, + 0, + 25, + 0, + 30, + 0, + 38, + 0, + 42, + 0, + 46, + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 57, + 0, + 74, + 0, + 76, + 0, + 80, + 0, + 87, + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 89, + 0, + 96, + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 100, + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 104, + 0, + 108, + 0, + 112, + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 118, + 0, + 122, + 0, + 127, + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 124))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 115))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 110))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 105))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 100))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 95))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 90))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 85))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 76))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 72))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 67))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 58))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 53))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 47))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 41))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 23))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 21))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 6))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 0, + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 7, + 1, + 12, + 1, + 19, + 1, + 23, + 1, + 30, + 1, + 37, + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 44, + 1, + 48, + 1, + 54, + 1, + 58, + 1, + 62, + 1, + 66, + 1, + 72, + 1, + 78, + 1, + 84, + 1, + 90, + 1, + 96, + 1, + 101, + 1, + 106, + 1, + 113, + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 117, + 1, + 122, + 1, + 127, + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 125))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 118))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 111))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 107))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 99))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 91))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 82))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 73))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 64))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 55))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 46))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 37))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 28))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 19))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 10))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 1, + 3, + 2, + 8, + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 13, + 2, + 16, + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 31, + 2, + 34, + 2, + 45, + 2, + 48, + 2, + 50, + 2, + 53, + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 110))), + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 107))), + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 105))), + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 100))), + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 95))), + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 90))), + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 86))), + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 81))), + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 76))), + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 11))), + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 7))), + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 5, + 3, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 12, + 3, + 19, + 3, + 26, + 3, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 33, + 3, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 40, + 3, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 47, + 3, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 54, + 3, + 60, + 3, + 66, + 3, + 73, + 3, + 80, + 3, + 87, + 3, + 94, + 3, + 102, + 3, + 110, + 3, + 118, + 3, + 126, + 3, + @bitCast(i8, @truncate(i8, -@as(c_int, 122))), + 3, + @bitCast(i8, @truncate(i8, -@as(c_int, 114))), + 3, + @bitCast(i8, @truncate(i8, -@as(c_int, 106))), + 3, + @bitCast(i8, @truncate(i8, -@as(c_int, 98))), + 3, + @bitCast(i8, @truncate(i8, -@as(c_int, 91))), + 3, + @bitCast(i8, @truncate(i8, -@as(c_int, 84))), + 3, + @bitCast(i8, @truncate(i8, -@as(c_int, 77))), + 3, + @bitCast(i8, @truncate(i8, -@as(c_int, 70))), + 3, + @bitCast(i8, @truncate(i8, -@as(c_int, 62))), + 3, + @bitCast(i8, @truncate(i8, -@as(c_int, 54))), + 3, + @bitCast(i8, @truncate(i8, -@as(c_int, 46))), + 3, + @bitCast(i8, @truncate(i8, -@as(c_int, 38))), + 3, + @bitCast(i8, @truncate(i8, -@as(c_int, 30))), + 3, + @bitCast(i8, @truncate(i8, -@as(c_int, 22))), + 3, + @bitCast(i8, @truncate(i8, -@as(c_int, 14))), + 3, + @bitCast(i8, @truncate(i8, -@as(c_int, 6))), + 3, + 1, + 4, + 8, + 4, + 15, + 4, + 22, + 4, + 30, + 4, + 38, + 4, + 46, + 4, + 54, + 4, + 62, + 4, + 70, + 4, + 78, + 4, + 86, + 4, + 93, + 4, + 100, + 4, + 107, + 4, + 114, + 4, + 122, + 4, + @bitCast(i8, @truncate(i8, -@as(c_int, 126))), + 4, + @bitCast(i8, @truncate(i8, -@as(c_int, 118))), + 4, + @bitCast(i8, @truncate(i8, -@as(c_int, 110))), + 4, + @bitCast(i8, @truncate(i8, -@as(c_int, 102))), + 4, + @bitCast(i8, @truncate(i8, -@as(c_int, 94))), + 4, + @bitCast(i8, @truncate(i8, -@as(c_int, 86))), + 4, + @bitCast(i8, @truncate(i8, -@as(c_int, 78))), + 4, + @bitCast(i8, @truncate(i8, -@as(c_int, 71))), + 4, + @bitCast(i8, @truncate(i8, -@as(c_int, 64))), + 4, + @bitCast(i8, @truncate(i8, -@as(c_int, 57))), + 4, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 52))), + 4, + @bitCast(i8, @truncate(i8, -@as(c_int, 41))), + 4, + @bitCast(i8, @truncate(i8, -@as(c_int, 36))), + 4, + @bitCast(i8, @truncate(i8, -@as(c_int, 28))), + 4, + @bitCast(i8, @truncate(i8, -@as(c_int, 24))), + 4, + @bitCast(i8, @truncate(i8, -@as(c_int, 15))), + 4, + @bitCast(i8, @truncate(i8, -@as(c_int, 8))), + 4, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 86, + 5, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 91, + 5, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 97, + 5, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 101, + 5, + @bitCast(i8, @truncate(i8, -@as(c_int, 92))), + 5, + 27, + 91, + 90, + 0, + 7, + 0, + 13, + 0, + 27, + 91, + 37, + 105, + 37, + 112, + 49, + 37, + 100, + 59, + 37, + 112, + 50, + 37, + 100, + 114, + 0, + 27, + 91, + 51, + 103, + 0, + 27, + 91, + 72, + 27, + 91, + 50, + 74, + 0, + 27, + 91, + 75, + 0, + 27, + 91, + 74, + 0, + 27, + 91, + 37, + 105, + 37, + 112, + 49, + 37, + 100, + 71, + 0, + 27, + 91, + 37, + 105, + 37, + 112, + 49, + 37, + 100, + 59, + 37, + 112, + 50, + 37, + 100, + 72, + 0, + 10, + 0, + 27, + 91, + 72, + 0, + 27, + 91, + 63, + 50, + 53, + 108, + 0, + 8, + 0, + 27, + 91, + 63, + 50, + 53, + 104, + 0, + 27, + 91, + 67, + 0, + 27, + 91, + 65, + 0, + 27, + 91, + 80, + 0, + 27, + 91, + 77, + 0, + 27, + 93, + 48, + 59, + 7, + 0, + 27, + 40, + 48, + 0, + 27, + 91, + 53, + 109, + 0, + 27, + 91, + 49, + 109, + 0, + 27, + 91, + 63, + 49, + 48, + 52, + 57, + 104, + 0, + 27, + 91, + 50, + 109, + 0, + 27, + 91, + 52, + 104, + 0, + 27, + 91, + 56, + 109, + 0, + 27, + 91, + 55, + 109, + 0, + 27, + 91, + 55, + 109, + 0, + 27, + 91, + 52, + 109, + 0, + 27, + 91, + 37, + 112, + 49, + 37, + 100, + 88, + 0, + 27, + 40, + 66, + 0, + 27, + 91, + 48, + 109, + 0, + 27, + 91, + 63, + 49, + 48, + 52, + 57, + 108, + 0, + 27, + 91, + 52, + 108, + 0, + 27, + 91, + 50, + 55, + 109, + 0, + 27, + 91, + 50, + 52, + 109, + 0, + 27, + 91, + 63, + 53, + 104, + 36, + 60, + 49, + 48, + 48, + 47, + 62, + 27, + 91, + 63, + 53, + 108, + 0, + 7, + 0, + 27, + 91, + 52, + 108, + 27, + 62, + 27, + 91, + 63, + 49, + 48, + 51, + 52, + 108, + 0, + 27, + 91, + 76, + 0, + 127, + 0, + 27, + 91, + 51, + 59, + 53, + 126, + 0, + 27, + 91, + 51, + 126, + 0, + 27, + 91, + 51, + 59, + 50, + 126, + 0, + 27, + 79, + 66, + 0, + 27, + 91, + 50, + 59, + 50, + 126, + 0, + 27, + 91, + 49, + 59, + 50, + 70, + 0, + 27, + 91, + 49, + 59, + 53, + 70, + 0, + 27, + 79, + 80, + 0, + 27, + 91, + 50, + 49, + 126, + 0, + 27, + 79, + 81, + 0, + 27, + 79, + 82, + 0, + 27, + 79, + 83, + 0, + 27, + 91, + 49, + 53, + 126, + 0, + 27, + 91, + 49, + 55, + 126, + 0, + 27, + 91, + 49, + 56, + 126, + 0, + 27, + 91, + 49, + 57, + 126, + 0, + 27, + 91, + 50, + 48, + 126, + 0, + 27, + 91, + 49, + 126, + 0, + 27, + 91, + 50, + 126, + 0, + 27, + 91, + 50, + 59, + 53, + 126, + 0, + 27, + 79, + 68, + 0, + 27, + 91, + 54, + 126, + 0, + 27, + 91, + 53, + 126, + 0, + 27, + 79, + 67, + 0, + 27, + 91, + 49, + 59, + 50, + 66, + 0, + 27, + 91, + 49, + 59, + 50, + 65, + 0, + 27, + 79, + 65, + 0, + 27, + 91, + 63, + 49, + 108, + 27, + 62, + 0, + 27, + 91, + 63, + 49, + 104, + 27, + 61, + 0, + 27, + 91, + 37, + 112, + 49, + 37, + 100, + 80, + 0, + 27, + 91, + 37, + 112, + 49, + 37, + 100, + 77, + 0, + 27, + 91, + 37, + 112, + 49, + 37, + 100, + 66, + 0, + 27, + 91, + 37, + 112, + 49, + 37, + 100, + 64, + 0, + 27, + 91, + 37, + 112, + 49, + 37, + 100, + 83, + 0, + 27, + 91, + 37, + 112, + 49, + 37, + 100, + 76, + 0, + 27, + 91, + 37, + 112, + 49, + 37, + 100, + 68, + 0, + 27, + 91, + 37, + 112, + 49, + 37, + 100, + 67, + 0, + 27, + 91, + 37, + 112, + 49, + 37, + 100, + 84, + 0, + 27, + 91, + 37, + 112, + 49, + 37, + 100, + 65, + 0, + 27, + 91, + 105, + 0, + 27, + 91, + 52, + 105, + 0, + 27, + 91, + 53, + 105, + 0, + 27, + 99, + 0, + 27, + 91, + 52, + 108, + 27, + 62, + 27, + 91, + 63, + 49, + 48, + 51, + 52, + 108, + 0, + 27, + 56, + 0, + 27, + 91, + 37, + 105, + 37, + 112, + 49, + 37, + 100, + 100, + 0, + 27, + 55, + 0, + 10, + 0, + 27, + 77, + 0, + 37, + 63, + 37, + 112, + 57, + 37, + 116, + 27, + 40, + 48, + 37, + 101, + 27, + 40, + 66, + 37, + 59, + 27, + 91, + 48, + 37, + 63, + 37, + 112, + 54, + 37, + 116, + 59, + 49, + 37, + 59, + 37, + 63, + 37, + 112, + 50, + 37, + 116, + 59, + 52, + 37, + 59, + 37, + 63, + 37, + 112, + 49, + 37, + 112, + 51, + 37, + 124, + 37, + 116, + 59, + 55, + 37, + 59, + 37, + 63, + 37, + 112, + 52, + 37, + 116, + 59, + 53, + 37, + 59, + 37, + 63, + 37, + 112, + 53, + 37, + 116, + 59, + 50, + 37, + 59, + 37, + 63, + 37, + 112, + 55, + 37, + 116, + 59, + 56, + 37, + 59, + 109, + 0, + 27, + 72, + 0, + 9, + 0, + 27, + 93, + 48, + 59, + 0, + 27, + 91, + 49, + 126, + 0, + 27, + 91, + 53, + 126, + 0, + 27, + 79, + 117, + 0, + 27, + 91, + 52, + 126, + 0, + 27, + 91, + 54, + 126, + 0, + 43, + 67, + 44, + 68, + 45, + 65, + 46, + 66, + 48, + 69, + 96, + 96, + 97, + 97, + 102, + 102, + 103, + 103, + 104, + 70, + 105, + 71, + 106, + 106, + 107, + 107, + 108, + 108, + 109, + 109, + 110, + 110, + 111, + 111, + 112, + 112, + 113, + 113, + 114, + 114, + 115, + 115, + 116, + 116, + 117, + 117, + 118, + 118, + 119, + 119, + 120, + 120, + 121, + 121, + 122, + 122, + 123, + 123, + 124, + 124, + 125, + 125, + 126, + 126, + 0, + 27, + 41, + 48, + 0, + 27, + 91, + 52, + 126, + 0, + 27, + 91, + 51, + 59, + 50, + 126, + 0, + 27, + 91, + 49, + 59, + 50, + 70, + 0, + 27, + 91, + 49, + 59, + 50, + 72, + 0, + 27, + 91, + 50, + 59, + 50, + 126, + 0, + 27, + 91, + 49, + 59, + 50, + 68, + 0, + 27, + 91, + 54, + 59, + 50, + 126, + 0, + 27, + 91, + 53, + 59, + 50, + 126, + 0, + 27, + 91, + 49, + 59, + 50, + 67, + 0, + 27, + 91, + 50, + 51, + 126, + 0, + 27, + 91, + 50, + 52, + 126, + 0, + 27, + 91, + 49, + 59, + 50, + 80, + 0, + 27, + 91, + 49, + 59, + 50, + 81, + 0, + 27, + 91, + 49, + 59, + 50, + 82, + 0, + 27, + 91, + 49, + 59, + 50, + 83, + 0, + 27, + 91, + 49, + 53, + 59, + 50, + 126, + 0, + 27, + 91, + 49, + 55, + 59, + 50, + 126, + 0, + 27, + 91, + 49, + 56, + 59, + 50, + 126, + 0, + 27, + 91, + 49, + 57, + 59, + 50, + 126, + 0, + 27, + 91, + 50, + 48, + 59, + 50, + 126, + 0, + 27, + 91, + 50, + 49, + 59, + 50, + 126, + 0, + 27, + 91, + 50, + 51, + 59, + 50, + 126, + 0, + 27, + 91, + 50, + 52, + 59, + 50, + 126, + 0, + 27, + 91, + 49, + 59, + 53, + 80, + 0, + 27, + 91, + 49, + 59, + 53, + 81, + 0, + 27, + 91, + 49, + 59, + 53, + 82, + 0, + 27, + 91, + 49, + 59, + 53, + 83, + 0, + 27, + 91, + 49, + 53, + 59, + 53, + 126, + 0, + 27, + 91, + 49, + 55, + 59, + 53, + 126, + 0, + 27, + 91, + 49, + 56, + 59, + 53, + 126, + 0, + 27, + 91, + 49, + 57, + 59, + 53, + 126, + 0, + 27, + 91, + 50, + 48, + 59, + 53, + 126, + 0, + 27, + 91, + 50, + 49, + 59, + 53, + 126, + 0, + 27, + 91, + 50, + 51, + 59, + 53, + 126, + 0, + 27, + 91, + 50, + 52, + 59, + 53, + 126, + 0, + 27, + 91, + 49, + 59, + 54, + 80, + 0, + 27, + 91, + 49, + 59, + 54, + 81, + 0, + 27, + 91, + 49, + 59, + 54, + 82, + 0, + 27, + 91, + 49, + 59, + 54, + 83, + 0, + 27, + 91, + 49, + 53, + 59, + 54, + 126, + 0, + 27, + 91, + 49, + 55, + 59, + 54, + 126, + 0, + 27, + 91, + 49, + 56, + 59, + 54, + 126, + 0, + 27, + 91, + 49, + 57, + 59, + 54, + 126, + 0, + 27, + 91, + 50, + 48, + 59, + 54, + 126, + 0, + 27, + 91, + 50, + 49, + 59, + 54, + 126, + 0, + 27, + 91, + 50, + 51, + 59, + 54, + 126, + 0, + 27, + 91, + 50, + 52, + 59, + 54, + 126, + 0, + 27, + 91, + 49, + 59, + 51, + 80, + 0, + 27, + 91, + 49, + 59, + 51, + 81, + 0, + 27, + 91, + 49, + 59, + 51, + 82, + 0, + 27, + 91, + 49, + 59, + 51, + 83, + 0, + 27, + 91, + 49, + 53, + 59, + 51, + 126, + 0, + 27, + 91, + 49, + 55, + 59, + 51, + 126, + 0, + 27, + 91, + 49, + 56, + 59, + 51, + 126, + 0, + 27, + 91, + 49, + 57, + 59, + 51, + 126, + 0, + 27, + 91, + 50, + 48, + 59, + 51, + 126, + 0, + 27, + 91, + 50, + 49, + 59, + 51, + 126, + 0, + 27, + 91, + 50, + 51, + 59, + 51, + 126, + 0, + 27, + 91, + 50, + 52, + 59, + 51, + 126, + 0, + 27, + 91, + 49, + 59, + 52, + 80, + 0, + 27, + 91, + 49, + 59, + 52, + 81, + 0, + 27, + 91, + 49, + 59, + 52, + 82, + 0, + 27, + 91, + 49, + 75, + 0, + 27, + 91, + 37, + 105, + 37, + 100, + 59, + 37, + 100, + 82, + 0, + 27, + 91, + 54, + 110, + 0, + 27, + 91, + 63, + 49, + 59, + 50, + 99, + 0, + 27, + 91, + 99, + 0, + 27, + 91, + 51, + 57, + 59, + 52, + 57, + 109, + 0, + 27, + 93, + 49, + 48, + 52, + 7, + 0, + 27, + 93, + 52, + 59, + 37, + 112, + 49, + 37, + 100, + 59, + 114, + 103, + 98, + 58, + 37, + 112, + 50, + 37, + 123, + 50, + 53, + 53, + 125, + 37, + 42, + 37, + 123, + 49, + 48, + 48, + 48, + 125, + 37, + 47, + 37, + 50, + 46, + 50, + 88, + 47, + 37, + 112, + 51, + 37, + 123, + 50, + 53, + 53, + 125, + 37, + 42, + 37, + 123, + 49, + 48, + 48, + 48, + 125, + 37, + 47, + 37, + 50, + 46, + 50, + 88, + 47, + 37, + 112, + 52, + 37, + 123, + 50, + 53, + 53, + 125, + 37, + 42, + 37, + 123, + 49, + 48, + 48, + 48, + 125, + 37, + 47, + 37, + 50, + 46, + 50, + 88, + 27, + 92, + 0, + 27, + 91, + 51, + 109, + 0, + 27, + 91, + 50, + 51, + 109, + 0, + 27, + 91, + 77, + 0, + 27, + 91, + 37, + 63, + 37, + 112, + 49, + 37, + 123, + 56, + 125, + 37, + 60, + 37, + 116, + 51, + 37, + 112, + 49, + 37, + 100, + 37, + 101, + 37, + 112, + 49, + 37, + 123, + 49, + 54, + 125, + 37, + 60, + 37, + 116, + 57, + 37, + 112, + 49, + 37, + 123, + 56, + 125, + 37, + 45, + 37, + 100, + 37, + 101, + 51, + 56, + 59, + 53, + 59, + 37, + 112, + 49, + 37, + 100, + 37, + 59, + 109, + 0, + 27, + 91, + 37, + 63, + 37, + 112, + 49, + 37, + 123, + 56, + 125, + 37, + 60, + 37, + 116, + 52, + 37, + 112, + 49, + 37, + 100, + 37, + 101, + 37, + 112, + 49, + 37, + 123, + 49, + 54, + 125, + 37, + 60, + 37, + 116, + 49, + 48, + 37, + 112, + 49, + 37, + 123, + 56, + 125, + 37, + 45, + 37, + 100, + 37, + 101, + 52, + 56, + 59, + 53, + 59, + 37, + 112, + 49, + 37, + 100, + 37, + 59, + 109, + 0, + 1, + 0, + 0, + 0, + 18, + 0, + 37, + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 29))), + 0, + 1, + 0, + 0, + 0, + 18, + 0, + 24, + 0, + 34, + 0, + 39, + 0, + 46, + 0, + 53, + 0, + 60, + 0, + 67, + 0, + 74, + 0, + 81, + 0, + 88, + 0, + 95, + 0, + 102, + 0, + 109, + 0, + 116, + 0, + 123, + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 127))), + 0, + 0, + 0, + 3, + 0, + 6, + 0, + 9, + 0, + 12, + 0, + 15, + 0, + 20, + 0, + 25, + 0, + 31, + 0, + 37, + 0, + 43, + 0, + 49, + 0, + 55, + 0, + 61, + 0, + 67, + 0, + 73, + 0, + 78, + 0, + 83, + 0, + 88, + 0, + 27, + 93, + 53, + 50, + 59, + 37, + 112, + 49, + 37, + 115, + 59, + 37, + 112, + 50, + 37, + 115, + 7, + 0, + 27, + 91, + 50, + 32, + 113, + 0, + 27, + 91, + 37, + 112, + 49, + 37, + 100, + 32, + 113, + 0, + 27, + 93, + 48, + 59, + 0, + 27, + 91, + 49, + 59, + 51, + 66, + 0, + 27, + 91, + 49, + 59, + 53, + 66, + 0, + 27, + 91, + 49, + 59, + 51, + 68, + 0, + 27, + 91, + 49, + 59, + 53, + 68, + 0, + 27, + 91, + 54, + 59, + 51, + 126, + 0, + 27, + 91, + 54, + 59, + 53, + 126, + 0, + 27, + 91, + 53, + 59, + 51, + 126, + 0, + 27, + 91, + 53, + 59, + 53, + 126, + 0, + 27, + 91, + 49, + 59, + 51, + 67, + 0, + 27, + 91, + 49, + 59, + 53, + 67, + 0, + 27, + 91, + 49, + 59, + 51, + 65, + 0, + 27, + 91, + 49, + 59, + 53, + 65, + 0, + 27, + 91, + 50, + 57, + 109, + 0, + 27, + 91, + 57, + 109, + 0, + 88, + 84, + 0, + 77, + 115, + 0, + 83, + 101, + 0, + 83, + 115, + 0, + 84, + 83, + 0, + 107, + 68, + 78, + 51, + 0, + 107, + 68, + 78, + 53, + 0, + 107, + 76, + 70, + 84, + 51, + 0, + 107, + 76, + 70, + 84, + 53, + 0, + 107, + 78, + 88, + 84, + 51, + 0, + 107, + 78, + 88, + 84, + 53, + 0, + 107, + 80, + 82, + 86, + 51, + 0, + 107, + 80, + 82, + 86, + 53, + 0, + 107, + 82, + 73, + 84, + 51, + 0, + 107, + 82, + 73, + 84, + 53, + 0, + 107, + 85, + 80, + 51, + 0, + 107, + 85, + 80, + 53, + 0, + 114, + 109, + 120, + 120, + 0, + 115, + 109, + 120, + 120, + 0, +}; +pub const tmux_256colour_terminfo: [3245]i8 = [3245]i8{ + 30, + 2, + 35, + 0, + 43, + 0, + 15, + 0, + 105, + 1, + 13, + 5, + 116, + 109, + 117, + 120, + 45, + 50, + 53, + 54, + 99, + 111, + 108, + 111, + 114, + 124, + 116, + 109, + 117, + 120, + 32, + 119, + 105, + 116, + 104, + 32, + 50, + 53, + 54, + 32, + 99, + 111, + 108, + 111, + 114, + 115, + 0, + 0, + 1, + 0, + 0, + 1, + 0, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 1, + 80, + 0, + 0, + 0, + 8, + 0, + 0, + 0, + 24, + 0, + 0, + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 0, + 1, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 4, + 0, + 6, + 0, + 8, + 0, + 25, + 0, + 30, + 0, + 37, + 0, + 41, + 0, + 45, + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 56, + 0, + 73, + 0, + 75, + 0, + 79, + 0, + 86, + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 88, + 0, + 100, + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 104, + 0, + 107, + 0, + 113, + 0, + 117, + 0, + 121, + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 127, + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 127))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 122))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 117))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 108))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 103))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 98))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 93))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 88))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 83))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 78))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 76))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 71))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 62))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 57))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 51))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 45))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 42))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 40))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 36))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 32))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 30))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 25))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 21))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 17))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 11))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 7))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 3))), + 0, + 1, + 1, + 7, + 1, + 13, + 1, + 19, + 1, + 25, + 1, + 31, + 1, + 36, + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 41, + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 45, + 1, + 50, + 1, + 55, + 1, + 59, + 1, + 66, + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 73, + 1, + 77, + 1, + 85, + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 93, + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 96, + 1, + 105, + 1, + 114, + 1, + 123, + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 124))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 115))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 106))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 97))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 88))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 79))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 62))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 59))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 48))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 45))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 43))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 40))), + 1, + 49, + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 52, + 2, + 54, + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 59, + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 124, + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 128))), + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 121))), + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 116))), + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 109))), + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 102))), + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 95))), + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 88))), + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 81))), + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 74))), + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 67))), + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 60))), + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 54))), + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 48))), + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 41))), + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 34))), + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 27))), + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 20))), + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 12))), + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 4))), + 2, + 4, + 3, + 12, + 3, + 20, + 3, + 28, + 3, + 36, + 3, + 44, + 3, + 51, + 3, + 58, + 3, + 65, + 3, + 72, + 3, + 80, + 3, + 88, + 3, + 96, + 3, + 104, + 3, + 112, + 3, + 120, + 3, + @bitCast(i8, @truncate(i8, -@as(c_int, 128))), + 3, + @bitCast(i8, @truncate(i8, -@as(c_int, 120))), + 3, + @bitCast(i8, @truncate(i8, -@as(c_int, 113))), + 3, + @bitCast(i8, @truncate(i8, -@as(c_int, 106))), + 3, + @bitCast(i8, @truncate(i8, -@as(c_int, 99))), + 3, + @bitCast(i8, @truncate(i8, -@as(c_int, 92))), + 3, + @bitCast(i8, @truncate(i8, -@as(c_int, 84))), + 3, + @bitCast(i8, @truncate(i8, -@as(c_int, 76))), + 3, + @bitCast(i8, @truncate(i8, -@as(c_int, 68))), + 3, + @bitCast(i8, @truncate(i8, -@as(c_int, 60))), + 3, + @bitCast(i8, @truncate(i8, -@as(c_int, 52))), + 3, + @bitCast(i8, @truncate(i8, -@as(c_int, 44))), + 3, + @bitCast(i8, @truncate(i8, -@as(c_int, 36))), + 3, + @bitCast(i8, @truncate(i8, -@as(c_int, 28))), + 3, + @bitCast(i8, @truncate(i8, -@as(c_int, 21))), + 3, + @bitCast(i8, @truncate(i8, -@as(c_int, 14))), + 3, + @bitCast(i8, @truncate(i8, -@as(c_int, 7))), + 3, + 0, + 4, + 8, + 4, + 16, + 4, + 24, + 4, + 32, + 4, + 40, + 4, + 48, + 4, + 56, + 4, + 64, + 4, + 71, + 4, + 78, + 4, + 85, + 4, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 90, + 4, + 101, + 4, + 106, + 4, + 114, + 4, + 118, + 4, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 127, + 4, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 124))), + 4, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 118))), + 4, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 114))), + 4, + @bitCast(i8, @truncate(i8, -@as(c_int, 51))), + 4, + 27, + 91, + 90, + 0, + 7, + 0, + 13, + 0, + 27, + 91, + 37, + 105, + 37, + 112, + 49, + 37, + 100, + 59, + 37, + 112, + 50, + 37, + 100, + 114, + 0, + 27, + 91, + 51, + 103, + 0, + 27, + 91, + 72, + 27, + 91, + 74, + 0, + 27, + 91, + 75, + 0, + 27, + 91, + 74, + 0, + 27, + 91, + 37, + 105, + 37, + 112, + 49, + 37, + 100, + 71, + 0, + 27, + 91, + 37, + 105, + 37, + 112, + 49, + 37, + 100, + 59, + 37, + 112, + 50, + 37, + 100, + 72, + 0, + 10, + 0, + 27, + 91, + 72, + 0, + 27, + 91, + 63, + 50, + 53, + 108, + 0, + 8, + 0, + 27, + 91, + 51, + 52, + 104, + 27, + 91, + 63, + 50, + 53, + 104, + 0, + 27, + 91, + 67, + 0, + 27, + 77, + 0, + 27, + 91, + 51, + 52, + 108, + 0, + 27, + 91, + 80, + 0, + 27, + 91, + 77, + 0, + 27, + 93, + 48, + 59, + 7, + 0, + 14, + 0, + 27, + 91, + 53, + 109, + 0, + 27, + 91, + 49, + 109, + 0, + 27, + 91, + 63, + 49, + 48, + 52, + 57, + 104, + 0, + 27, + 91, + 50, + 109, + 0, + 27, + 91, + 52, + 104, + 0, + 27, + 91, + 56, + 109, + 0, + 27, + 91, + 55, + 109, + 0, + 27, + 91, + 55, + 109, + 0, + 27, + 91, + 52, + 109, + 0, + 15, + 0, + 27, + 91, + 109, + 15, + 0, + 27, + 91, + 63, + 49, + 48, + 52, + 57, + 108, + 0, + 27, + 91, + 52, + 108, + 0, + 27, + 91, + 50, + 55, + 109, + 0, + 27, + 91, + 50, + 52, + 109, + 0, + 27, + 103, + 0, + 7, + 0, + 27, + 41, + 48, + 0, + 27, + 91, + 76, + 0, + 127, + 0, + 27, + 91, + 51, + 126, + 0, + 27, + 79, + 66, + 0, + 27, + 79, + 80, + 0, + 27, + 91, + 50, + 49, + 126, + 0, + 27, + 79, + 81, + 0, + 27, + 79, + 82, + 0, + 27, + 79, + 83, + 0, + 27, + 91, + 49, + 53, + 126, + 0, + 27, + 91, + 49, + 55, + 126, + 0, + 27, + 91, + 49, + 56, + 126, + 0, + 27, + 91, + 49, + 57, + 126, + 0, + 27, + 91, + 50, + 48, + 126, + 0, + 27, + 91, + 49, + 126, + 0, + 27, + 91, + 50, + 126, + 0, + 27, + 79, + 68, + 0, + 27, + 91, + 54, + 126, + 0, + 27, + 91, + 53, + 126, + 0, + 27, + 79, + 67, + 0, + 27, + 91, + 49, + 59, + 50, + 66, + 0, + 27, + 91, + 49, + 59, + 50, + 65, + 0, + 27, + 79, + 65, + 0, + 27, + 91, + 63, + 49, + 108, + 27, + 62, + 0, + 27, + 91, + 63, + 49, + 104, + 27, + 61, + 0, + 27, + 69, + 0, + 27, + 91, + 37, + 112, + 49, + 37, + 100, + 80, + 0, + 27, + 91, + 37, + 112, + 49, + 37, + 100, + 77, + 0, + 27, + 91, + 37, + 112, + 49, + 37, + 100, + 66, + 0, + 27, + 91, + 37, + 112, + 49, + 37, + 100, + 64, + 0, + 27, + 91, + 37, + 112, + 49, + 37, + 100, + 83, + 0, + 27, + 91, + 37, + 112, + 49, + 37, + 100, + 76, + 0, + 27, + 91, + 37, + 112, + 49, + 37, + 100, + 68, + 0, + 27, + 91, + 37, + 112, + 49, + 37, + 100, + 67, + 0, + 27, + 91, + 37, + 112, + 49, + 37, + 100, + 65, + 0, + 27, + 99, + 27, + 91, + 63, + 49, + 48, + 48, + 48, + 108, + 27, + 91, + 63, + 50, + 53, + 104, + 0, + 27, + 56, + 0, + 27, + 91, + 37, + 105, + 37, + 112, + 49, + 37, + 100, + 100, + 0, + 27, + 55, + 0, + 10, + 0, + 27, + 77, + 0, + 27, + 91, + 48, + 37, + 63, + 37, + 112, + 54, + 37, + 116, + 59, + 49, + 37, + 59, + 37, + 63, + 37, + 112, + 50, + 37, + 116, + 59, + 52, + 37, + 59, + 37, + 63, + 37, + 112, + 49, + 37, + 112, + 51, + 37, + 124, + 37, + 116, + 59, + 55, + 37, + 59, + 37, + 63, + 37, + 112, + 52, + 37, + 116, + 59, + 53, + 37, + 59, + 37, + 63, + 37, + 112, + 53, + 37, + 116, + 59, + 50, + 37, + 59, + 37, + 63, + 37, + 112, + 55, + 37, + 116, + 59, + 56, + 37, + 59, + 109, + 37, + 63, + 37, + 112, + 57, + 37, + 116, + 14, + 37, + 101, + 15, + 37, + 59, + 0, + 27, + 72, + 0, + 9, + 0, + 27, + 93, + 48, + 59, + 0, + 43, + 43, + 44, + 44, + 45, + 45, + 46, + 46, + 48, + 48, + 96, + 96, + 97, + 97, + 102, + 102, + 103, + 103, + 104, + 104, + 105, + 105, + 106, + 106, + 107, + 107, + 108, + 108, + 109, + 109, + 110, + 110, + 111, + 111, + 112, + 112, + 113, + 113, + 114, + 114, + 115, + 115, + 116, + 116, + 117, + 117, + 118, + 118, + 119, + 119, + 120, + 120, + 121, + 121, + 122, + 122, + 123, + 123, + 124, + 124, + 125, + 125, + 126, + 126, + 0, + 27, + 91, + 90, + 0, + 27, + 40, + 66, + 27, + 41, + 48, + 0, + 27, + 91, + 52, + 126, + 0, + 27, + 91, + 51, + 59, + 50, + 126, + 0, + 27, + 91, + 49, + 59, + 50, + 70, + 0, + 27, + 91, + 49, + 59, + 50, + 72, + 0, + 27, + 91, + 50, + 59, + 50, + 126, + 0, + 27, + 91, + 49, + 59, + 50, + 68, + 0, + 27, + 91, + 54, + 59, + 50, + 126, + 0, + 27, + 91, + 53, + 59, + 50, + 126, + 0, + 27, + 91, + 49, + 59, + 50, + 67, + 0, + 27, + 91, + 50, + 51, + 126, + 0, + 27, + 91, + 50, + 52, + 126, + 0, + 27, + 91, + 49, + 59, + 50, + 80, + 0, + 27, + 91, + 49, + 59, + 50, + 81, + 0, + 27, + 91, + 49, + 59, + 50, + 82, + 0, + 27, + 91, + 49, + 59, + 50, + 83, + 0, + 27, + 91, + 49, + 53, + 59, + 50, + 126, + 0, + 27, + 91, + 49, + 55, + 59, + 50, + 126, + 0, + 27, + 91, + 49, + 56, + 59, + 50, + 126, + 0, + 27, + 91, + 49, + 57, + 59, + 50, + 126, + 0, + 27, + 91, + 50, + 48, + 59, + 50, + 126, + 0, + 27, + 91, + 50, + 49, + 59, + 50, + 126, + 0, + 27, + 91, + 50, + 51, + 59, + 50, + 126, + 0, + 27, + 91, + 50, + 52, + 59, + 50, + 126, + 0, + 27, + 91, + 49, + 59, + 53, + 80, + 0, + 27, + 91, + 49, + 59, + 53, + 81, + 0, + 27, + 91, + 49, + 59, + 53, + 82, + 0, + 27, + 91, + 49, + 59, + 53, + 83, + 0, + 27, + 91, + 49, + 53, + 59, + 53, + 126, + 0, + 27, + 91, + 49, + 55, + 59, + 53, + 126, + 0, + 27, + 91, + 49, + 56, + 59, + 53, + 126, + 0, + 27, + 91, + 49, + 57, + 59, + 53, + 126, + 0, + 27, + 91, + 50, + 48, + 59, + 53, + 126, + 0, + 27, + 91, + 50, + 49, + 59, + 53, + 126, + 0, + 27, + 91, + 50, + 51, + 59, + 53, + 126, + 0, + 27, + 91, + 50, + 52, + 59, + 53, + 126, + 0, + 27, + 91, + 49, + 59, + 54, + 80, + 0, + 27, + 91, + 49, + 59, + 54, + 81, + 0, + 27, + 91, + 49, + 59, + 54, + 82, + 0, + 27, + 91, + 49, + 59, + 54, + 83, + 0, + 27, + 91, + 49, + 53, + 59, + 54, + 126, + 0, + 27, + 91, + 49, + 55, + 59, + 54, + 126, + 0, + 27, + 91, + 49, + 56, + 59, + 54, + 126, + 0, + 27, + 91, + 49, + 57, + 59, + 54, + 126, + 0, + 27, + 91, + 50, + 48, + 59, + 54, + 126, + 0, + 27, + 91, + 50, + 49, + 59, + 54, + 126, + 0, + 27, + 91, + 50, + 51, + 59, + 54, + 126, + 0, + 27, + 91, + 50, + 52, + 59, + 54, + 126, + 0, + 27, + 91, + 49, + 59, + 51, + 80, + 0, + 27, + 91, + 49, + 59, + 51, + 81, + 0, + 27, + 91, + 49, + 59, + 51, + 82, + 0, + 27, + 91, + 49, + 59, + 51, + 83, + 0, + 27, + 91, + 49, + 53, + 59, + 51, + 126, + 0, + 27, + 91, + 49, + 55, + 59, + 51, + 126, + 0, + 27, + 91, + 49, + 56, + 59, + 51, + 126, + 0, + 27, + 91, + 49, + 57, + 59, + 51, + 126, + 0, + 27, + 91, + 50, + 48, + 59, + 51, + 126, + 0, + 27, + 91, + 50, + 49, + 59, + 51, + 126, + 0, + 27, + 91, + 50, + 51, + 59, + 51, + 126, + 0, + 27, + 91, + 50, + 52, + 59, + 51, + 126, + 0, + 27, + 91, + 49, + 59, + 52, + 80, + 0, + 27, + 91, + 49, + 59, + 52, + 81, + 0, + 27, + 91, + 49, + 59, + 52, + 82, + 0, + 27, + 91, + 49, + 75, + 0, + 27, + 91, + 37, + 105, + 37, + 100, + 59, + 37, + 100, + 82, + 0, + 27, + 91, + 54, + 110, + 0, + 27, + 91, + 63, + 49, + 59, + 50, + 99, + 0, + 27, + 91, + 99, + 0, + 27, + 91, + 51, + 57, + 59, + 52, + 57, + 109, + 0, + 27, + 91, + 51, + 109, + 0, + 27, + 91, + 50, + 51, + 109, + 0, + 27, + 91, + 77, + 0, + 27, + 91, + 37, + 63, + 37, + 112, + 49, + 37, + 123, + 56, + 125, + 37, + 60, + 37, + 116, + 51, + 37, + 112, + 49, + 37, + 100, + 37, + 101, + 37, + 112, + 49, + 37, + 123, + 49, + 54, + 125, + 37, + 60, + 37, + 116, + 57, + 37, + 112, + 49, + 37, + 123, + 56, + 125, + 37, + 45, + 37, + 100, + 37, + 101, + 51, + 56, + 59, + 53, + 59, + 37, + 112, + 49, + 37, + 100, + 37, + 59, + 109, + 0, + 27, + 91, + 37, + 63, + 37, + 112, + 49, + 37, + 123, + 56, + 125, + 37, + 60, + 37, + 116, + 52, + 37, + 112, + 49, + 37, + 100, + 37, + 101, + 37, + 112, + 49, + 37, + 123, + 49, + 54, + 125, + 37, + 60, + 37, + 116, + 49, + 48, + 37, + 112, + 49, + 37, + 123, + 56, + 125, + 37, + 45, + 37, + 100, + 37, + 101, + 52, + 56, + 59, + 53, + 59, + 37, + 112, + 49, + 37, + 100, + 37, + 59, + 109, + 0, + 0, + 2, + 0, + 1, + 0, + 64, + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 125))), + 0, + 33, + 3, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 7, + 0, + 19, + 0, + 23, + 0, + 28, + 0, + 46, + 0, + 54, + 0, + 60, + 0, + 71, + 0, + 81, + 0, + 86, + 0, + 93, + 0, + 100, + 0, + 107, + 0, + 114, + 0, + 121, + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 128))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 121))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 114))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 107))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 100))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 93))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 86))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 79))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 72))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 65))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 58))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 51))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 44))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 37))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 30))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 23))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 16))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 9))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + 0, + 5, + 1, + 12, + 1, + 19, + 1, + 26, + 1, + 33, + 1, + 40, + 1, + 47, + 1, + 54, + 1, + 61, + 1, + 68, + 1, + 75, + 1, + 82, + 1, + 89, + 1, + 96, + 1, + 103, + 1, + 110, + 1, + 117, + 1, + 124, + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 125))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 118))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 111))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 104))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 97))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 90))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 83))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 76))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 69))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 62))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 56))), + 1, + 0, + 0, + 3, + 0, + 6, + 0, + 9, + 0, + 12, + 0, + 15, + 0, + 18, + 0, + 21, + 0, + 24, + 0, + 27, + 0, + 30, + 0, + 36, + 0, + 39, + 0, + 42, + 0, + 47, + 0, + 52, + 0, + 57, + 0, + 62, + 0, + 67, + 0, + 71, + 0, + 76, + 0, + 81, + 0, + 86, + 0, + 91, + 0, + 96, + 0, + 102, + 0, + 108, + 0, + 114, + 0, + 120, + 0, + 126, + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 124))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 118))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 112))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 106))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 100))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 95))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 90))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 85))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 80))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 75))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 69))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 63))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 57))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 51))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 45))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 39))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 33))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 27))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 21))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 15))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 9))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 3))), + 0, + 3, + 1, + 9, + 1, + 15, + 1, + 21, + 1, + 27, + 1, + 33, + 1, + 39, + 1, + 45, + 1, + 49, + 1, + 54, + 1, + 59, + 1, + 64, + 1, + 69, + 1, + 74, + 1, + 79, + 1, + 27, + 93, + 49, + 49, + 50, + 7, + 0, + 27, + 93, + 49, + 50, + 59, + 37, + 112, + 49, + 37, + 115, + 7, + 0, + 27, + 40, + 66, + 0, + 27, + 91, + 51, + 74, + 0, + 27, + 93, + 53, + 50, + 59, + 37, + 112, + 49, + 37, + 115, + 59, + 37, + 112, + 50, + 37, + 115, + 7, + 0, + 27, + 40, + 37, + 112, + 49, + 37, + 99, + 0, + 27, + 91, + 50, + 32, + 113, + 0, + 27, + 91, + 52, + 58, + 37, + 112, + 49, + 37, + 100, + 109, + 0, + 27, + 91, + 37, + 112, + 49, + 37, + 100, + 32, + 113, + 0, + 27, + 93, + 48, + 59, + 0, + 27, + 91, + 51, + 59, + 51, + 126, + 0, + 27, + 91, + 51, + 59, + 52, + 126, + 0, + 27, + 91, + 51, + 59, + 53, + 126, + 0, + 27, + 91, + 51, + 59, + 54, + 126, + 0, + 27, + 91, + 51, + 59, + 55, + 126, + 0, + 27, + 91, + 49, + 59, + 50, + 66, + 0, + 27, + 91, + 49, + 59, + 51, + 66, + 0, + 27, + 91, + 49, + 59, + 52, + 66, + 0, + 27, + 91, + 49, + 59, + 53, + 66, + 0, + 27, + 91, + 49, + 59, + 54, + 66, + 0, + 27, + 91, + 49, + 59, + 55, + 66, + 0, + 27, + 91, + 49, + 59, + 51, + 70, + 0, + 27, + 91, + 49, + 59, + 52, + 70, + 0, + 27, + 91, + 49, + 59, + 53, + 70, + 0, + 27, + 91, + 49, + 59, + 54, + 70, + 0, + 27, + 91, + 49, + 59, + 55, + 70, + 0, + 27, + 91, + 49, + 59, + 51, + 72, + 0, + 27, + 91, + 49, + 59, + 52, + 72, + 0, + 27, + 91, + 49, + 59, + 53, + 72, + 0, + 27, + 91, + 49, + 59, + 54, + 72, + 0, + 27, + 91, + 49, + 59, + 55, + 72, + 0, + 27, + 91, + 50, + 59, + 51, + 126, + 0, + 27, + 91, + 50, + 59, + 52, + 126, + 0, + 27, + 91, + 50, + 59, + 53, + 126, + 0, + 27, + 91, + 50, + 59, + 54, + 126, + 0, + 27, + 91, + 50, + 59, + 55, + 126, + 0, + 27, + 91, + 49, + 59, + 51, + 68, + 0, + 27, + 91, + 49, + 59, + 52, + 68, + 0, + 27, + 91, + 49, + 59, + 53, + 68, + 0, + 27, + 91, + 49, + 59, + 54, + 68, + 0, + 27, + 91, + 49, + 59, + 55, + 68, + 0, + 27, + 91, + 54, + 59, + 51, + 126, + 0, + 27, + 91, + 54, + 59, + 52, + 126, + 0, + 27, + 91, + 54, + 59, + 53, + 126, + 0, + 27, + 91, + 54, + 59, + 54, + 126, + 0, + 27, + 91, + 54, + 59, + 55, + 126, + 0, + 27, + 91, + 53, + 59, + 51, + 126, + 0, + 27, + 91, + 53, + 59, + 52, + 126, + 0, + 27, + 91, + 53, + 59, + 53, + 126, + 0, + 27, + 91, + 53, + 59, + 54, + 126, + 0, + 27, + 91, + 53, + 59, + 55, + 126, + 0, + 27, + 91, + 49, + 59, + 51, + 67, + 0, + 27, + 91, + 49, + 59, + 52, + 67, + 0, + 27, + 91, + 49, + 59, + 53, + 67, + 0, + 27, + 91, + 49, + 59, + 54, + 67, + 0, + 27, + 91, + 49, + 59, + 55, + 67, + 0, + 27, + 91, + 49, + 59, + 50, + 65, + 0, + 27, + 91, + 49, + 59, + 51, + 65, + 0, + 27, + 91, + 49, + 59, + 52, + 65, + 0, + 27, + 91, + 49, + 59, + 53, + 65, + 0, + 27, + 91, + 49, + 59, + 54, + 65, + 0, + 27, + 91, + 49, + 59, + 55, + 65, + 0, + 27, + 91, + 50, + 57, + 109, + 0, + 27, + 91, + 57, + 109, + 0, + 65, + 88, + 0, + 71, + 48, + 0, + 85, + 56, + 0, + 67, + 114, + 0, + 67, + 115, + 0, + 69, + 48, + 0, + 69, + 51, + 0, + 77, + 115, + 0, + 83, + 48, + 0, + 83, + 101, + 0, + 83, + 109, + 117, + 108, + 120, + 0, + 83, + 115, + 0, + 84, + 83, + 0, + 107, + 68, + 67, + 51, + 0, + 107, + 68, + 67, + 52, + 0, + 107, + 68, + 67, + 53, + 0, + 107, + 68, + 67, + 54, + 0, + 107, + 68, + 67, + 55, + 0, + 107, + 68, + 78, + 0, + 107, + 68, + 78, + 51, + 0, + 107, + 68, + 78, + 52, + 0, + 107, + 68, + 78, + 53, + 0, + 107, + 68, + 78, + 54, + 0, + 107, + 68, + 78, + 55, + 0, + 107, + 69, + 78, + 68, + 51, + 0, + 107, + 69, + 78, + 68, + 52, + 0, + 107, + 69, + 78, + 68, + 53, + 0, + 107, + 69, + 78, + 68, + 54, + 0, + 107, + 69, + 78, + 68, + 55, + 0, + 107, + 72, + 79, + 77, + 51, + 0, + 107, + 72, + 79, + 77, + 52, + 0, + 107, + 72, + 79, + 77, + 53, + 0, + 107, + 72, + 79, + 77, + 54, + 0, + 107, + 72, + 79, + 77, + 55, + 0, + 107, + 73, + 67, + 51, + 0, + 107, + 73, + 67, + 52, + 0, + 107, + 73, + 67, + 53, + 0, + 107, + 73, + 67, + 54, + 0, + 107, + 73, + 67, + 55, + 0, + 107, + 76, + 70, + 84, + 51, + 0, + 107, + 76, + 70, + 84, + 52, + 0, + 107, + 76, + 70, + 84, + 53, + 0, + 107, + 76, + 70, + 84, + 54, + 0, + 107, + 76, + 70, + 84, + 55, + 0, + 107, + 78, + 88, + 84, + 51, + 0, + 107, + 78, + 88, + 84, + 52, + 0, + 107, + 78, + 88, + 84, + 53, + 0, + 107, + 78, + 88, + 84, + 54, + 0, + 107, + 78, + 88, + 84, + 55, + 0, + 107, + 80, + 82, + 86, + 51, + 0, + 107, + 80, + 82, + 86, + 52, + 0, + 107, + 80, + 82, + 86, + 53, + 0, + 107, + 80, + 82, + 86, + 54, + 0, + 107, + 80, + 82, + 86, + 55, + 0, + 107, + 82, + 73, + 84, + 51, + 0, + 107, + 82, + 73, + 84, + 52, + 0, + 107, + 82, + 73, + 84, + 53, + 0, + 107, + 82, + 73, + 84, + 54, + 0, + 107, + 82, + 73, + 84, + 55, + 0, + 107, + 85, + 80, + 0, + 107, + 85, + 80, + 51, + 0, + 107, + 85, + 80, + 52, + 0, + 107, + 85, + 80, + 53, + 0, + 107, + 85, + 80, + 54, + 0, + 107, + 85, + 80, + 55, + 0, + 114, + 109, + 120, + 120, + 0, + 115, + 109, + 120, + 120, + 0, +}; +pub const vte_256colour_terminfo: [3504]i8 = [3504]i8{ + 30, + 2, + 39, + 0, + 38, + 0, + 15, + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 99))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 49))), + 5, + 118, + 116, + 101, + 45, + 50, + 53, + 54, + 99, + 111, + 108, + 111, + 114, + 124, + 86, + 84, + 69, + 32, + 119, + 105, + 116, + 104, + 32, + 120, + 116, + 101, + 114, + 109, + 32, + 50, + 53, + 54, + 45, + 99, + 111, + 108, + 111, + 114, + 115, + 0, + 0, + 1, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 80, + 0, + 0, + 0, + 8, + 0, + 0, + 0, + 24, + 0, + 0, + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 0, + 1, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 4, + 0, + 6, + 0, + 8, + 0, + 25, + 0, + 30, + 0, + 38, + 0, + 42, + 0, + 46, + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 57, + 0, + 74, + 0, + 76, + 0, + 80, + 0, + 87, + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 89, + 0, + 96, + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 100, + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 104, + 0, + 108, + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 112, + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 114, + 0, + 119, + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 128))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 123))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 118))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 113))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 108))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 103))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 98))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 89))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 87))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 81))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 68))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 63))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 57))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 51))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 33))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 0, + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 4, + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 6, + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 11, + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 15, + 1, + 19, + 1, + 25, + 1, + 29, + 1, + 33, + 1, + 37, + 1, + 43, + 1, + 49, + 1, + 55, + 1, + 61, + 1, + 67, + 1, + 71, + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 76, + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 80, + 1, + 85, + 1, + 90, + 1, + 94, + 1, + 101, + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 108, + 1, + 112, + 1, + 120, + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 128))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 119))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 110))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 101))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 92))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 83))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 74))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 65))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 56))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 47))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 38))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 35))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 16, + 2, + 19, + 2, + 30, + 2, + 33, + 2, + 35, + 2, + 38, + 2, + 116, + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 119, + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 121, + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 125, + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 78))), + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 74))), + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 68))), + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 62))), + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 58))), + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 54))), + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 50))), + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 45))), + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 38))), + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 33))), + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 26))), + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 19))), + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 12))), + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 5))), + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 2, + 3, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 9, + 3, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 16, + 3, + 22, + 3, + 28, + 3, + 35, + 3, + 42, + 3, + 49, + 3, + 56, + 3, + 64, + 3, + 72, + 3, + 80, + 3, + 88, + 3, + 96, + 3, + 104, + 3, + 112, + 3, + 120, + 3, + 127, + 3, + @bitCast(i8, @truncate(i8, -@as(c_int, 122))), + 3, + @bitCast(i8, @truncate(i8, -@as(c_int, 115))), + 3, + @bitCast(i8, @truncate(i8, -@as(c_int, 108))), + 3, + @bitCast(i8, @truncate(i8, -@as(c_int, 100))), + 3, + @bitCast(i8, @truncate(i8, -@as(c_int, 92))), + 3, + @bitCast(i8, @truncate(i8, -@as(c_int, 84))), + 3, + @bitCast(i8, @truncate(i8, -@as(c_int, 76))), + 3, + @bitCast(i8, @truncate(i8, -@as(c_int, 68))), + 3, + @bitCast(i8, @truncate(i8, -@as(c_int, 60))), + 3, + @bitCast(i8, @truncate(i8, -@as(c_int, 52))), + 3, + @bitCast(i8, @truncate(i8, -@as(c_int, 44))), + 3, + @bitCast(i8, @truncate(i8, -@as(c_int, 37))), + 3, + @bitCast(i8, @truncate(i8, -@as(c_int, 30))), + 3, + @bitCast(i8, @truncate(i8, -@as(c_int, 23))), + 3, + @bitCast(i8, @truncate(i8, -@as(c_int, 16))), + 3, + @bitCast(i8, @truncate(i8, -@as(c_int, 8))), + 3, + 0, + 4, + 8, + 4, + 16, + 4, + 24, + 4, + 32, + 4, + 40, + 4, + 48, + 4, + 55, + 4, + 62, + 4, + 69, + 4, + 76, + 4, + 84, + 4, + 92, + 4, + 100, + 4, + 108, + 4, + 116, + 4, + 124, + 4, + @bitCast(i8, @truncate(i8, -@as(c_int, 124))), + 4, + @bitCast(i8, @truncate(i8, -@as(c_int, 116))), + 4, + @bitCast(i8, @truncate(i8, -@as(c_int, 109))), + 4, + @bitCast(i8, @truncate(i8, -@as(c_int, 102))), + 4, + @bitCast(i8, @truncate(i8, -@as(c_int, 95))), + 4, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 90))), + 4, + @bitCast(i8, @truncate(i8, -@as(c_int, 79))), + 4, + @bitCast(i8, @truncate(i8, -@as(c_int, 74))), + 4, + @bitCast(i8, @truncate(i8, -@as(c_int, 55))), + 4, + @bitCast(i8, @truncate(i8, -@as(c_int, 51))), + 4, + @bitCast(i8, @truncate(i8, -@as(c_int, 42))), + 4, + @bitCast(i8, @truncate(i8, -@as(c_int, 35))), + 4, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 59, + 5, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 64, + 5, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 70, + 5, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 74, + 5, + @bitCast(i8, @truncate(i8, -@as(c_int, 119))), + 5, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 55))), + 5, + @bitCast(i8, @truncate(i8, -@as(c_int, 52))), + 5, + 27, + 91, + 90, + 0, + 7, + 0, + 13, + 0, + 27, + 91, + 37, + 105, + 37, + 112, + 49, + 37, + 100, + 59, + 37, + 112, + 50, + 37, + 100, + 114, + 0, + 27, + 91, + 51, + 103, + 0, + 27, + 91, + 72, + 27, + 91, + 50, + 74, + 0, + 27, + 91, + 75, + 0, + 27, + 91, + 74, + 0, + 27, + 91, + 37, + 105, + 37, + 112, + 49, + 37, + 100, + 71, + 0, + 27, + 91, + 37, + 105, + 37, + 112, + 49, + 37, + 100, + 59, + 37, + 112, + 50, + 37, + 100, + 72, + 0, + 10, + 0, + 27, + 91, + 72, + 0, + 27, + 91, + 63, + 50, + 53, + 108, + 0, + 8, + 0, + 27, + 91, + 63, + 50, + 53, + 104, + 0, + 27, + 91, + 67, + 0, + 27, + 91, + 65, + 0, + 27, + 91, + 80, + 0, + 27, + 91, + 77, + 0, + 14, + 0, + 27, + 91, + 49, + 109, + 0, + 27, + 55, + 27, + 91, + 63, + 52, + 55, + 104, + 0, + 27, + 91, + 50, + 109, + 0, + 27, + 91, + 52, + 104, + 0, + 27, + 91, + 56, + 109, + 0, + 27, + 91, + 55, + 109, + 0, + 27, + 91, + 55, + 109, + 0, + 27, + 91, + 52, + 109, + 0, + 27, + 91, + 37, + 112, + 49, + 37, + 100, + 88, + 0, + 15, + 0, + 27, + 91, + 48, + 109, + 15, + 0, + 27, + 91, + 50, + 74, + 27, + 91, + 63, + 52, + 55, + 108, + 27, + 56, + 0, + 27, + 91, + 52, + 108, + 0, + 27, + 91, + 50, + 55, + 109, + 0, + 27, + 91, + 50, + 52, + 109, + 0, + 27, + 91, + 63, + 53, + 104, + 36, + 60, + 49, + 48, + 48, + 47, + 62, + 27, + 91, + 63, + 53, + 108, + 0, + 27, + 91, + 109, + 27, + 91, + 63, + 55, + 104, + 27, + 91, + 52, + 108, + 27, + 62, + 27, + 55, + 27, + 91, + 114, + 27, + 91, + 63, + 49, + 59, + 51, + 59, + 52, + 59, + 54, + 108, + 27, + 56, + 0, + 27, + 91, + 76, + 0, + 127, + 0, + 27, + 91, + 51, + 126, + 0, + 27, + 79, + 66, + 0, + 27, + 79, + 80, + 0, + 27, + 91, + 50, + 49, + 126, + 0, + 27, + 79, + 81, + 0, + 27, + 79, + 82, + 0, + 27, + 79, + 83, + 0, + 27, + 91, + 49, + 53, + 126, + 0, + 27, + 91, + 49, + 55, + 126, + 0, + 27, + 91, + 49, + 56, + 126, + 0, + 27, + 91, + 49, + 57, + 126, + 0, + 27, + 91, + 50, + 48, + 126, + 0, + 27, + 79, + 72, + 0, + 27, + 91, + 50, + 126, + 0, + 27, + 79, + 68, + 0, + 27, + 91, + 54, + 126, + 0, + 27, + 91, + 53, + 126, + 0, + 27, + 79, + 67, + 0, + 27, + 91, + 49, + 59, + 50, + 66, + 0, + 27, + 91, + 49, + 59, + 50, + 65, + 0, + 27, + 79, + 65, + 0, + 27, + 91, + 63, + 49, + 108, + 27, + 62, + 0, + 27, + 91, + 63, + 49, + 104, + 27, + 61, + 0, + 27, + 91, + 37, + 112, + 49, + 37, + 100, + 80, + 0, + 27, + 91, + 37, + 112, + 49, + 37, + 100, + 77, + 0, + 27, + 91, + 37, + 112, + 49, + 37, + 100, + 66, + 0, + 27, + 91, + 37, + 112, + 49, + 37, + 100, + 64, + 0, + 27, + 91, + 37, + 112, + 49, + 37, + 100, + 83, + 0, + 27, + 91, + 37, + 112, + 49, + 37, + 100, + 76, + 0, + 27, + 91, + 37, + 112, + 49, + 37, + 100, + 68, + 0, + 27, + 91, + 37, + 112, + 49, + 37, + 100, + 67, + 0, + 27, + 91, + 37, + 112, + 49, + 37, + 100, + 84, + 0, + 27, + 91, + 37, + 112, + 49, + 37, + 100, + 65, + 0, + 27, + 99, + 0, + 27, + 55, + 27, + 91, + 114, + 27, + 56, + 27, + 91, + 109, + 27, + 91, + 63, + 55, + 104, + 27, + 91, + 33, + 112, + 27, + 91, + 63, + 49, + 59, + 51, + 59, + 52, + 59, + 54, + 108, + 27, + 91, + 52, + 108, + 27, + 62, + 27, + 91, + 63, + 49, + 48, + 48, + 48, + 108, + 27, + 91, + 63, + 50, + 53, + 104, + 0, + 27, + 56, + 0, + 27, + 91, + 37, + 105, + 37, + 112, + 49, + 37, + 100, + 100, + 0, + 27, + 55, + 0, + 10, + 0, + 27, + 77, + 0, + 27, + 91, + 48, + 37, + 63, + 37, + 112, + 54, + 37, + 116, + 59, + 49, + 37, + 59, + 37, + 63, + 37, + 112, + 50, + 37, + 116, + 59, + 52, + 37, + 59, + 37, + 63, + 37, + 112, + 53, + 37, + 116, + 59, + 50, + 37, + 59, + 37, + 63, + 37, + 112, + 55, + 37, + 116, + 59, + 56, + 37, + 59, + 37, + 63, + 37, + 112, + 49, + 37, + 112, + 51, + 37, + 124, + 37, + 116, + 59, + 55, + 37, + 59, + 109, + 37, + 63, + 37, + 112, + 57, + 37, + 116, + 14, + 37, + 101, + 15, + 37, + 59, + 0, + 27, + 72, + 0, + 9, + 0, + 27, + 91, + 69, + 0, + 96, + 96, + 97, + 97, + 102, + 102, + 103, + 103, + 105, + 105, + 106, + 106, + 107, + 107, + 108, + 108, + 109, + 109, + 110, + 110, + 111, + 111, + 112, + 112, + 113, + 113, + 114, + 114, + 115, + 115, + 116, + 116, + 117, + 117, + 118, + 118, + 119, + 119, + 120, + 120, + 121, + 121, + 122, + 122, + 123, + 123, + 124, + 124, + 125, + 125, + 126, + 126, + 0, + 27, + 91, + 90, + 0, + 27, + 91, + 63, + 55, + 104, + 0, + 27, + 91, + 63, + 55, + 108, + 0, + 27, + 41, + 48, + 0, + 27, + 79, + 70, + 0, + 27, + 79, + 77, + 0, + 27, + 91, + 49, + 126, + 0, + 27, + 91, + 51, + 59, + 50, + 126, + 0, + 27, + 91, + 52, + 126, + 0, + 27, + 91, + 49, + 59, + 50, + 70, + 0, + 27, + 91, + 49, + 59, + 50, + 72, + 0, + 27, + 91, + 50, + 59, + 50, + 126, + 0, + 27, + 91, + 49, + 59, + 50, + 68, + 0, + 27, + 91, + 54, + 59, + 50, + 126, + 0, + 27, + 91, + 53, + 59, + 50, + 126, + 0, + 27, + 91, + 49, + 59, + 50, + 67, + 0, + 27, + 91, + 50, + 51, + 126, + 0, + 27, + 91, + 50, + 52, + 126, + 0, + 27, + 91, + 49, + 59, + 50, + 80, + 0, + 27, + 91, + 49, + 59, + 50, + 81, + 0, + 27, + 91, + 49, + 59, + 50, + 82, + 0, + 27, + 91, + 49, + 59, + 50, + 83, + 0, + 27, + 91, + 49, + 53, + 59, + 50, + 126, + 0, + 27, + 91, + 49, + 55, + 59, + 50, + 126, + 0, + 27, + 91, + 49, + 56, + 59, + 50, + 126, + 0, + 27, + 91, + 49, + 57, + 59, + 50, + 126, + 0, + 27, + 91, + 50, + 48, + 59, + 50, + 126, + 0, + 27, + 91, + 50, + 49, + 59, + 50, + 126, + 0, + 27, + 91, + 50, + 51, + 59, + 50, + 126, + 0, + 27, + 91, + 50, + 52, + 59, + 50, + 126, + 0, + 27, + 91, + 49, + 59, + 53, + 80, + 0, + 27, + 91, + 49, + 59, + 53, + 81, + 0, + 27, + 91, + 49, + 59, + 53, + 82, + 0, + 27, + 91, + 49, + 59, + 53, + 83, + 0, + 27, + 91, + 49, + 53, + 59, + 53, + 126, + 0, + 27, + 91, + 49, + 55, + 59, + 53, + 126, + 0, + 27, + 91, + 49, + 56, + 59, + 53, + 126, + 0, + 27, + 91, + 49, + 57, + 59, + 53, + 126, + 0, + 27, + 91, + 50, + 48, + 59, + 53, + 126, + 0, + 27, + 91, + 50, + 49, + 59, + 53, + 126, + 0, + 27, + 91, + 50, + 51, + 59, + 53, + 126, + 0, + 27, + 91, + 50, + 52, + 59, + 53, + 126, + 0, + 27, + 91, + 49, + 59, + 54, + 80, + 0, + 27, + 91, + 49, + 59, + 54, + 81, + 0, + 27, + 91, + 49, + 59, + 54, + 82, + 0, + 27, + 91, + 49, + 59, + 54, + 83, + 0, + 27, + 91, + 49, + 53, + 59, + 54, + 126, + 0, + 27, + 91, + 49, + 55, + 59, + 54, + 126, + 0, + 27, + 91, + 49, + 56, + 59, + 54, + 126, + 0, + 27, + 91, + 49, + 57, + 59, + 54, + 126, + 0, + 27, + 91, + 50, + 48, + 59, + 54, + 126, + 0, + 27, + 91, + 50, + 49, + 59, + 54, + 126, + 0, + 27, + 91, + 50, + 51, + 59, + 54, + 126, + 0, + 27, + 91, + 50, + 52, + 59, + 54, + 126, + 0, + 27, + 91, + 49, + 59, + 51, + 80, + 0, + 27, + 91, + 49, + 59, + 51, + 81, + 0, + 27, + 91, + 49, + 59, + 51, + 82, + 0, + 27, + 91, + 49, + 59, + 51, + 83, + 0, + 27, + 91, + 49, + 53, + 59, + 51, + 126, + 0, + 27, + 91, + 49, + 55, + 59, + 51, + 126, + 0, + 27, + 91, + 49, + 56, + 59, + 51, + 126, + 0, + 27, + 91, + 49, + 57, + 59, + 51, + 126, + 0, + 27, + 91, + 50, + 48, + 59, + 51, + 126, + 0, + 27, + 91, + 50, + 49, + 59, + 51, + 126, + 0, + 27, + 91, + 50, + 51, + 59, + 51, + 126, + 0, + 27, + 91, + 50, + 52, + 59, + 51, + 126, + 0, + 27, + 91, + 49, + 59, + 52, + 80, + 0, + 27, + 91, + 49, + 59, + 52, + 81, + 0, + 27, + 91, + 49, + 59, + 52, + 82, + 0, + 27, + 91, + 49, + 75, + 0, + 27, + 91, + 37, + 105, + 37, + 100, + 59, + 37, + 100, + 82, + 0, + 27, + 91, + 54, + 110, + 0, + 27, + 91, + 63, + 37, + 91, + 59, + 48, + 49, + 50, + 51, + 52, + 53, + 54, + 55, + 56, + 57, + 93, + 99, + 0, + 27, + 91, + 99, + 0, + 27, + 91, + 51, + 57, + 59, + 52, + 57, + 109, + 0, + 27, + 93, + 49, + 48, + 52, + 7, + 0, + 27, + 93, + 52, + 59, + 37, + 112, + 49, + 37, + 100, + 59, + 114, + 103, + 98, + 58, + 37, + 112, + 50, + 37, + 123, + 50, + 53, + 53, + 125, + 37, + 42, + 37, + 123, + 49, + 48, + 48, + 48, + 125, + 37, + 47, + 37, + 50, + 46, + 50, + 88, + 47, + 37, + 112, + 51, + 37, + 123, + 50, + 53, + 53, + 125, + 37, + 42, + 37, + 123, + 49, + 48, + 48, + 48, + 125, + 37, + 47, + 37, + 50, + 46, + 50, + 88, + 47, + 37, + 112, + 52, + 37, + 123, + 50, + 53, + 53, + 125, + 37, + 42, + 37, + 123, + 49, + 48, + 48, + 48, + 125, + 37, + 47, + 37, + 50, + 46, + 50, + 88, + 27, + 92, + 0, + 27, + 91, + 51, + 109, + 0, + 27, + 91, + 50, + 51, + 109, + 0, + 27, + 91, + 60, + 0, + 27, + 91, + 37, + 63, + 37, + 112, + 49, + 37, + 123, + 56, + 125, + 37, + 60, + 37, + 116, + 51, + 37, + 112, + 49, + 37, + 100, + 37, + 101, + 37, + 112, + 49, + 37, + 123, + 49, + 54, + 125, + 37, + 60, + 37, + 116, + 57, + 37, + 112, + 49, + 37, + 123, + 56, + 125, + 37, + 45, + 37, + 100, + 37, + 101, + 51, + 56, + 59, + 53, + 59, + 37, + 112, + 49, + 37, + 100, + 37, + 59, + 109, + 0, + 27, + 91, + 37, + 63, + 37, + 112, + 49, + 37, + 123, + 56, + 125, + 37, + 60, + 37, + 116, + 52, + 37, + 112, + 49, + 37, + 100, + 37, + 101, + 37, + 112, + 49, + 37, + 123, + 49, + 54, + 125, + 37, + 60, + 37, + 116, + 49, + 48, + 37, + 112, + 49, + 37, + 123, + 56, + 125, + 37, + 45, + 37, + 100, + 37, + 101, + 52, + 56, + 59, + 53, + 59, + 37, + 112, + 49, + 37, + 100, + 37, + 59, + 109, + 0, + 27, + 108, + 0, + 27, + 109, + 0, + 0, + 1, + 0, + 0, + 0, + 59, + 0, + 119, + 0, + 22, + 3, + 1, + 0, + 0, + 0, + 6, + 0, + 12, + 0, + 23, + 0, + 55, + 0, + 62, + 0, + 69, + 0, + 76, + 0, + 83, + 0, + 90, + 0, + 97, + 0, + 104, + 0, + 111, + 0, + 118, + 0, + 125, + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 124))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 117))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 110))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 103))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 96))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 89))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 82))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 75))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 68))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 61))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 54))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 47))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 40))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 33))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 26))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 19))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 12))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 5))), + 0, + 2, + 1, + 9, + 1, + 16, + 1, + 23, + 1, + 30, + 1, + 37, + 1, + 44, + 1, + 51, + 1, + 58, + 1, + 65, + 1, + 72, + 1, + 79, + 1, + 86, + 1, + 93, + 1, + 100, + 1, + 107, + 1, + 114, + 1, + 121, + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 128))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 121))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 114))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 107))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 100))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 93))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 87))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 82))), + 1, + 0, + 0, + 3, + 0, + 8, + 0, + 13, + 0, + 19, + 0, + 22, + 0, + 27, + 0, + 32, + 0, + 37, + 0, + 42, + 0, + 47, + 0, + 51, + 0, + 56, + 0, + 61, + 0, + 66, + 0, + 71, + 0, + 76, + 0, + 82, + 0, + 88, + 0, + 94, + 0, + 100, + 0, + 106, + 0, + 112, + 0, + 118, + 0, + 124, + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 126))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 120))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 115))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 110))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 105))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 100))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 95))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 89))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 83))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 77))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 71))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 65))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 59))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 53))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 47))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 41))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 35))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 29))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 23))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 17))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 11))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 5))), + 0, + 1, + 1, + 7, + 1, + 13, + 1, + 19, + 1, + 25, + 1, + 29, + 1, + 34, + 1, + 39, + 1, + 44, + 1, + 49, + 1, + 54, + 1, + 59, + 1, + 64, + 1, + 27, + 91, + 53, + 53, + 109, + 0, + 27, + 91, + 53, + 51, + 109, + 0, + 27, + 91, + 52, + 58, + 37, + 112, + 49, + 37, + 100, + 109, + 0, + 27, + 91, + 63, + 49, + 48, + 48, + 54, + 59, + 49, + 48, + 48, + 48, + 37, + 63, + 37, + 112, + 49, + 37, + 123, + 49, + 125, + 37, + 61, + 37, + 116, + 104, + 37, + 101, + 108, + 37, + 59, + 0, + 27, + 91, + 51, + 59, + 51, + 126, + 0, + 27, + 91, + 51, + 59, + 52, + 126, + 0, + 27, + 91, + 51, + 59, + 53, + 126, + 0, + 27, + 91, + 51, + 59, + 54, + 126, + 0, + 27, + 91, + 51, + 59, + 55, + 126, + 0, + 27, + 91, + 49, + 59, + 50, + 66, + 0, + 27, + 91, + 49, + 59, + 51, + 66, + 0, + 27, + 91, + 49, + 59, + 52, + 66, + 0, + 27, + 91, + 49, + 59, + 53, + 66, + 0, + 27, + 91, + 49, + 59, + 54, + 66, + 0, + 27, + 91, + 49, + 59, + 55, + 66, + 0, + 27, + 91, + 49, + 59, + 51, + 70, + 0, + 27, + 91, + 49, + 59, + 52, + 70, + 0, + 27, + 91, + 49, + 59, + 53, + 70, + 0, + 27, + 91, + 49, + 59, + 54, + 70, + 0, + 27, + 91, + 49, + 59, + 55, + 70, + 0, + 27, + 91, + 49, + 59, + 51, + 72, + 0, + 27, + 91, + 49, + 59, + 52, + 72, + 0, + 27, + 91, + 49, + 59, + 53, + 72, + 0, + 27, + 91, + 49, + 59, + 54, + 72, + 0, + 27, + 91, + 49, + 59, + 55, + 72, + 0, + 27, + 91, + 50, + 59, + 51, + 126, + 0, + 27, + 91, + 50, + 59, + 52, + 126, + 0, + 27, + 91, + 50, + 59, + 53, + 126, + 0, + 27, + 91, + 50, + 59, + 54, + 126, + 0, + 27, + 91, + 50, + 59, + 55, + 126, + 0, + 27, + 91, + 49, + 59, + 51, + 68, + 0, + 27, + 91, + 49, + 59, + 52, + 68, + 0, + 27, + 91, + 49, + 59, + 53, + 68, + 0, + 27, + 91, + 49, + 59, + 54, + 68, + 0, + 27, + 91, + 49, + 59, + 55, + 68, + 0, + 27, + 91, + 54, + 59, + 51, + 126, + 0, + 27, + 91, + 54, + 59, + 52, + 126, + 0, + 27, + 91, + 54, + 59, + 53, + 126, + 0, + 27, + 91, + 54, + 59, + 54, + 126, + 0, + 27, + 91, + 54, + 59, + 55, + 126, + 0, + 27, + 91, + 53, + 59, + 51, + 126, + 0, + 27, + 91, + 53, + 59, + 52, + 126, + 0, + 27, + 91, + 53, + 59, + 53, + 126, + 0, + 27, + 91, + 53, + 59, + 54, + 126, + 0, + 27, + 91, + 53, + 59, + 55, + 126, + 0, + 27, + 91, + 49, + 59, + 51, + 67, + 0, + 27, + 91, + 49, + 59, + 52, + 67, + 0, + 27, + 91, + 49, + 59, + 53, + 67, + 0, + 27, + 91, + 49, + 59, + 54, + 67, + 0, + 27, + 91, + 49, + 59, + 55, + 67, + 0, + 27, + 91, + 49, + 59, + 50, + 65, + 0, + 27, + 91, + 49, + 59, + 51, + 65, + 0, + 27, + 91, + 49, + 59, + 52, + 65, + 0, + 27, + 91, + 49, + 59, + 53, + 65, + 0, + 27, + 91, + 49, + 59, + 54, + 65, + 0, + 27, + 91, + 49, + 59, + 55, + 65, + 0, + 27, + 91, + 50, + 57, + 109, + 0, + 27, + 91, + 57, + 109, + 0, + 27, + 91, + 60, + 37, + 105, + 37, + 112, + 51, + 37, + 100, + 59, + 37, + 112, + 49, + 37, + 100, + 59, + 37, + 112, + 50, + 37, + 100, + 59, + 37, + 63, + 37, + 112, + 52, + 37, + 116, + 77, + 37, + 101, + 109, + 37, + 59, + 0, + 88, + 84, + 0, + 82, + 109, + 111, + 108, + 0, + 83, + 109, + 111, + 108, + 0, + 83, + 109, + 117, + 108, + 120, + 0, + 88, + 77, + 0, + 107, + 68, + 67, + 51, + 0, + 107, + 68, + 67, + 52, + 0, + 107, + 68, + 67, + 53, + 0, + 107, + 68, + 67, + 54, + 0, + 107, + 68, + 67, + 55, + 0, + 107, + 68, + 78, + 0, + 107, + 68, + 78, + 51, + 0, + 107, + 68, + 78, + 52, + 0, + 107, + 68, + 78, + 53, + 0, + 107, + 68, + 78, + 54, + 0, + 107, + 68, + 78, + 55, + 0, + 107, + 69, + 78, + 68, + 51, + 0, + 107, + 69, + 78, + 68, + 52, + 0, + 107, + 69, + 78, + 68, + 53, + 0, + 107, + 69, + 78, + 68, + 54, + 0, + 107, + 69, + 78, + 68, + 55, + 0, + 107, + 72, + 79, + 77, + 51, + 0, + 107, + 72, + 79, + 77, + 52, + 0, + 107, + 72, + 79, + 77, + 53, + 0, + 107, + 72, + 79, + 77, + 54, + 0, + 107, + 72, + 79, + 77, + 55, + 0, + 107, + 73, + 67, + 51, + 0, + 107, + 73, + 67, + 52, + 0, + 107, + 73, + 67, + 53, + 0, + 107, + 73, + 67, + 54, + 0, + 107, + 73, + 67, + 55, + 0, + 107, + 76, + 70, + 84, + 51, + 0, + 107, + 76, + 70, + 84, + 52, + 0, + 107, + 76, + 70, + 84, + 53, + 0, + 107, + 76, + 70, + 84, + 54, + 0, + 107, + 76, + 70, + 84, + 55, + 0, + 107, + 78, + 88, + 84, + 51, + 0, + 107, + 78, + 88, + 84, + 52, + 0, + 107, + 78, + 88, + 84, + 53, + 0, + 107, + 78, + 88, + 84, + 54, + 0, + 107, + 78, + 88, + 84, + 55, + 0, + 107, + 80, + 82, + 86, + 51, + 0, + 107, + 80, + 82, + 86, + 52, + 0, + 107, + 80, + 82, + 86, + 53, + 0, + 107, + 80, + 82, + 86, + 54, + 0, + 107, + 80, + 82, + 86, + 55, + 0, + 107, + 82, + 73, + 84, + 51, + 0, + 107, + 82, + 73, + 84, + 52, + 0, + 107, + 82, + 73, + 84, + 53, + 0, + 107, + 82, + 73, + 84, + 54, + 0, + 107, + 82, + 73, + 84, + 55, + 0, + 107, + 85, + 80, + 0, + 107, + 85, + 80, + 51, + 0, + 107, + 85, + 80, + 52, + 0, + 107, + 85, + 80, + 53, + 0, + 107, + 85, + 80, + 54, + 0, + 107, + 85, + 80, + 55, + 0, + 114, + 109, + 120, + 120, + 0, + 115, + 109, + 120, + 120, + 0, + 120, + 109, + 0, +}; +pub const vtpcon_terminfo: [2858]i8 = [2858]i8{ + 30, + 2, + 71, + 0, + 38, + 0, + 15, + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 99))), + 1, + 47, + 4, + 118, + 116, + 112, + 99, + 111, + 110, + 124, + 65, + 78, + 73, + 83, + 32, + 101, + 109, + 117, + 108, + 97, + 116, + 105, + 111, + 110, + 32, + 102, + 111, + 114, + 32, + 99, + 111, + 110, + 115, + 111, + 108, + 101, + 32, + 118, + 105, + 114, + 116, + 117, + 97, + 108, + 32, + 116, + 101, + 114, + 109, + 105, + 110, + 97, + 108, + 32, + 115, + 101, + 113, + 117, + 101, + 110, + 99, + 101, + 32, + 119, + 105, + 116, + 104, + 32, + 108, + 105, + 98, + 117, + 118, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 80, + 0, + 0, + 0, + 8, + 0, + 0, + 0, + 24, + 0, + 0, + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 0, + 1, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 4, + 0, + 6, + 0, + 8, + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 25, + 0, + 33, + 0, + 37, + 0, + 41, + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 52, + 0, + 69, + 0, + 73, + 0, + 77, + 0, + 84, + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 86, + 0, + 99, + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 103, + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 107, + 0, + 111, + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 115, + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 119, + 0, + 124, + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 123))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 118))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 113))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 108))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 99))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 95))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 90))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 81))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 75))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 69))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 59))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 55))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 53))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 48))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 44))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 39))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 33))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 28))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 23))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 18))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 13))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 7))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 0, + 5, + 1, + 11, + 1, + 16, + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 21, + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 25, + 1, + 30, + 1, + 35, + 1, + 39, + 1, + 46, + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 53, + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 57, + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 60, + 1, + 69, + 1, + 78, + 1, + 87, + 1, + 96, + 1, + 105, + 1, + 114, + 1, + 123, + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 124))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 115))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 106))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 86))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 83))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 72))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 69))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 67))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 64))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 21))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 18))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 16))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 12))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 8))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 4))), + 1, + 0, + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 4, + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 27, + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 31, + 2, + 36, + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 40, + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 47, + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 54, + 2, + 61, + 2, + 68, + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 75, + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 82, + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 89, + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 96, + 2, + 102, + 2, + 108, + 2, + 114, + 2, + 120, + 2, + 126, + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 124))), + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 118))), + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 112))), + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 106))), + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 100))), + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 94))), + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 88))), + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 82))), + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 76))), + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 70))), + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 64))), + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 58))), + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 52))), + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 46))), + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 40))), + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 34))), + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 28))), + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 22))), + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 16))), + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 10))), + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 4))), + 2, + 2, + 3, + 8, + 3, + 14, + 3, + 21, + 3, + 27, + 3, + 33, + 3, + 39, + 3, + 45, + 3, + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 51, + 3, + 56, + 3, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 63, + 3, + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 72, + 3, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 91))), + 3, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 86))), + 3, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 80))), + 3, + @bitCast(i8, @truncate(i8, -@as(c_int, 17))), + 3, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 27, + 91, + 90, + 0, + 7, + 0, + 13, + 0, + 27, + 91, + 37, + 105, + 37, + 112, + 49, + 37, + 100, + 59, + 37, + 112, + 50, + 37, + 100, + 114, + 0, + 27, + 91, + 72, + 27, + 91, + 50, + 74, + 0, + 27, + 91, + 75, + 0, + 27, + 91, + 74, + 0, + 27, + 91, + 37, + 105, + 37, + 112, + 49, + 37, + 100, + 71, + 0, + 27, + 91, + 37, + 105, + 37, + 112, + 49, + 37, + 100, + 59, + 37, + 112, + 50, + 37, + 100, + 72, + 0, + 27, + 91, + 66, + 0, + 27, + 91, + 72, + 0, + 27, + 91, + 63, + 50, + 53, + 108, + 0, + 8, + 0, + 27, + 91, + 63, + 49, + 50, + 108, + 27, + 91, + 63, + 50, + 53, + 104, + 0, + 27, + 91, + 67, + 0, + 27, + 91, + 65, + 0, + 27, + 91, + 80, + 0, + 27, + 91, + 77, + 0, + 27, + 40, + 48, + 0, + 27, + 91, + 49, + 109, + 0, + 27, + 91, + 63, + 49, + 48, + 52, + 57, + 104, + 0, + 27, + 91, + 55, + 109, + 0, + 27, + 91, + 55, + 109, + 0, + 27, + 91, + 52, + 109, + 0, + 27, + 91, + 37, + 112, + 49, + 37, + 100, + 88, + 0, + 27, + 40, + 66, + 0, + 27, + 91, + 48, + 109, + 0, + 27, + 91, + 63, + 49, + 48, + 52, + 57, + 108, + 0, + 27, + 91, + 50, + 55, + 109, + 0, + 27, + 91, + 50, + 52, + 109, + 0, + 27, + 91, + 33, + 112, + 27, + 91, + 63, + 51, + 108, + 0, + 27, + 91, + 76, + 0, + 8, + 0, + 27, + 91, + 51, + 126, + 0, + 27, + 91, + 66, + 0, + 27, + 91, + 91, + 65, + 0, + 27, + 91, + 50, + 49, + 126, + 0, + 27, + 91, + 91, + 66, + 0, + 27, + 91, + 91, + 67, + 0, + 27, + 91, + 91, + 68, + 0, + 27, + 91, + 91, + 69, + 0, + 27, + 91, + 49, + 55, + 126, + 0, + 27, + 91, + 49, + 56, + 126, + 0, + 27, + 91, + 49, + 57, + 126, + 0, + 27, + 91, + 50, + 48, + 126, + 0, + 27, + 91, + 49, + 126, + 0, + 27, + 91, + 50, + 126, + 0, + 27, + 91, + 68, + 0, + 27, + 91, + 54, + 126, + 0, + 27, + 91, + 53, + 126, + 0, + 27, + 91, + 67, + 0, + 27, + 91, + 49, + 59, + 50, + 66, + 0, + 27, + 91, + 49, + 59, + 50, + 65, + 0, + 27, + 91, + 65, + 0, + 27, + 69, + 0, + 27, + 91, + 37, + 112, + 49, + 37, + 100, + 80, + 0, + 27, + 91, + 37, + 112, + 49, + 37, + 100, + 77, + 0, + 27, + 91, + 37, + 112, + 49, + 37, + 100, + 66, + 0, + 27, + 91, + 37, + 112, + 49, + 37, + 100, + 64, + 0, + 27, + 91, + 37, + 112, + 49, + 37, + 100, + 83, + 0, + 27, + 91, + 37, + 112, + 49, + 37, + 100, + 76, + 0, + 27, + 91, + 37, + 112, + 49, + 37, + 100, + 68, + 0, + 27, + 91, + 37, + 112, + 49, + 37, + 100, + 67, + 0, + 27, + 91, + 37, + 112, + 49, + 37, + 100, + 84, + 0, + 27, + 91, + 37, + 112, + 49, + 37, + 100, + 65, + 0, + 37, + 112, + 49, + 37, + 99, + 27, + 91, + 37, + 112, + 50, + 37, + 123, + 49, + 125, + 37, + 45, + 37, + 100, + 98, + 0, + 27, + 56, + 0, + 27, + 91, + 37, + 105, + 37, + 112, + 49, + 37, + 100, + 100, + 0, + 27, + 55, + 0, + 10, + 0, + 27, + 77, + 0, + 27, + 91, + 48, + 37, + 63, + 37, + 112, + 49, + 37, + 112, + 51, + 37, + 124, + 37, + 116, + 59, + 55, + 37, + 59, + 37, + 63, + 37, + 112, + 50, + 37, + 116, + 59, + 52, + 37, + 59, + 37, + 63, + 37, + 112, + 54, + 37, + 116, + 59, + 49, + 37, + 59, + 109, + 0, + 27, + 72, + 0, + 9, + 0, + 27, + 79, + 119, + 0, + 27, + 79, + 121, + 0, + 27, + 91, + 71, + 0, + 27, + 79, + 113, + 0, + 27, + 79, + 115, + 0, + 106, + 106, + 107, + 107, + 108, + 108, + 109, + 109, + 110, + 110, + 113, + 113, + 116, + 116, + 117, + 117, + 118, + 118, + 119, + 119, + 120, + 120, + 0, + 27, + 91, + 90, + 0, + 27, + 91, + 52, + 126, + 0, + 27, + 79, + 77, + 0, + 27, + 91, + 51, + 59, + 50, + 126, + 0, + 27, + 91, + 52, + 59, + 50, + 126, + 0, + 27, + 91, + 49, + 59, + 50, + 126, + 0, + 27, + 91, + 50, + 59, + 50, + 126, + 0, + 27, + 91, + 49, + 59, + 50, + 68, + 0, + 27, + 91, + 54, + 59, + 50, + 126, + 0, + 27, + 91, + 53, + 59, + 50, + 126, + 0, + 27, + 91, + 49, + 59, + 50, + 67, + 0, + 27, + 91, + 50, + 51, + 126, + 0, + 27, + 91, + 50, + 52, + 126, + 0, + 27, + 91, + 50, + 53, + 126, + 0, + 27, + 91, + 50, + 54, + 126, + 0, + 27, + 91, + 50, + 56, + 126, + 0, + 27, + 91, + 50, + 57, + 126, + 0, + 27, + 91, + 51, + 49, + 126, + 0, + 27, + 91, + 51, + 50, + 126, + 0, + 27, + 91, + 51, + 51, + 126, + 0, + 27, + 91, + 51, + 52, + 126, + 0, + 27, + 91, + 50, + 51, + 36, + 0, + 27, + 91, + 50, + 52, + 36, + 0, + 27, + 91, + 49, + 49, + 94, + 0, + 27, + 91, + 49, + 50, + 94, + 0, + 27, + 91, + 49, + 51, + 94, + 0, + 27, + 91, + 49, + 52, + 94, + 0, + 27, + 91, + 49, + 53, + 94, + 0, + 27, + 91, + 49, + 55, + 94, + 0, + 27, + 91, + 49, + 56, + 94, + 0, + 27, + 91, + 49, + 57, + 94, + 0, + 27, + 91, + 50, + 48, + 94, + 0, + 27, + 91, + 50, + 49, + 94, + 0, + 27, + 91, + 50, + 51, + 94, + 0, + 27, + 91, + 50, + 52, + 94, + 0, + 27, + 91, + 50, + 53, + 94, + 0, + 27, + 91, + 50, + 54, + 94, + 0, + 27, + 91, + 50, + 56, + 94, + 0, + 27, + 91, + 50, + 57, + 94, + 0, + 27, + 91, + 51, + 49, + 94, + 0, + 27, + 91, + 49, + 59, + 54, + 83, + 0, + 27, + 91, + 51, + 50, + 94, + 0, + 27, + 91, + 51, + 51, + 94, + 0, + 27, + 91, + 51, + 52, + 94, + 0, + 27, + 91, + 50, + 51, + 64, + 0, + 27, + 91, + 50, + 52, + 64, + 0, + 27, + 91, + 49, + 75, + 0, + 27, + 91, + 63, + 54, + 57, + 108, + 0, + 27, + 91, + 51, + 57, + 59, + 52, + 57, + 109, + 0, + 27, + 93, + 52, + 59, + 37, + 112, + 49, + 37, + 100, + 59, + 114, + 103, + 98, + 58, + 37, + 112, + 50, + 37, + 123, + 50, + 53, + 53, + 125, + 37, + 42, + 37, + 123, + 49, + 48, + 48, + 48, + 125, + 37, + 47, + 37, + 50, + 46, + 50, + 88, + 47, + 37, + 112, + 51, + 37, + 123, + 50, + 53, + 53, + 125, + 37, + 42, + 37, + 123, + 49, + 48, + 48, + 48, + 125, + 37, + 47, + 37, + 50, + 46, + 50, + 88, + 47, + 37, + 112, + 52, + 37, + 123, + 50, + 53, + 53, + 125, + 37, + 42, + 37, + 123, + 49, + 48, + 48, + 48, + 125, + 37, + 47, + 37, + 50, + 46, + 50, + 88, + 27, + 0, + 27, + 91, + 51, + 109, + 0, + 27, + 91, + 50, + 51, + 109, + 0, + 27, + 91, + 37, + 63, + 37, + 112, + 49, + 37, + 123, + 56, + 125, + 37, + 60, + 37, + 116, + 51, + 37, + 112, + 49, + 37, + 100, + 37, + 101, + 37, + 112, + 49, + 37, + 123, + 49, + 54, + 125, + 37, + 60, + 37, + 116, + 57, + 37, + 112, + 49, + 37, + 123, + 56, + 125, + 37, + 45, + 37, + 100, + 37, + 101, + 51, + 56, + 59, + 53, + 59, + 37, + 112, + 49, + 37, + 100, + 37, + 59, + 109, + 0, + 27, + 91, + 37, + 63, + 37, + 112, + 49, + 37, + 123, + 56, + 125, + 37, + 60, + 37, + 116, + 52, + 37, + 112, + 49, + 37, + 100, + 37, + 101, + 37, + 112, + 49, + 37, + 123, + 49, + 54, + 125, + 37, + 60, + 37, + 116, + 49, + 48, + 37, + 112, + 49, + 37, + 123, + 56, + 125, + 37, + 45, + 37, + 100, + 37, + 101, + 52, + 56, + 59, + 53, + 59, + 37, + 112, + 49, + 37, + 100, + 37, + 59, + 109, + 0, + 0, + 2, + 0, + 0, + 0, + 74, + 0, + 92, + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 46))), + 1, + 1, + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 0, + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 5, + 0, + 11, + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 21, + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 28, + 0, + 32, + 0, + 36, + 0, + 40, + 0, + 44, + 0, + 48, + 0, + 52, + 0, + 56, + 0, + 60, + 0, + 64, + 0, + 68, + 0, + 72, + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 0, + 0, + 3, + 0, + 6, + 0, + 9, + 0, + 12, + 0, + 15, + 0, + 18, + 0, + 21, + 0, + 24, + 0, + 27, + 0, + 32, + 0, + 37, + 0, + 42, + 0, + 47, + 0, + 52, + 0, + 56, + 0, + 61, + 0, + 66, + 0, + 71, + 0, + 76, + 0, + 81, + 0, + 87, + 0, + 93, + 0, + 99, + 0, + 105, + 0, + 111, + 0, + 117, + 0, + 123, + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 127))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 121))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 115))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 110))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 105))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 100))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 95))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 90))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 84))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 78))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 72))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 66))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 60))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 54))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 48))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 42))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 36))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 30))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 24))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 18))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 12))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 6))), + 0, + 0, + 1, + 6, + 1, + 12, + 1, + 18, + 1, + 24, + 1, + 30, + 1, + 34, + 1, + 39, + 1, + 44, + 1, + 49, + 1, + 54, + 1, + 59, + 1, + 63, + 1, + 67, + 1, + 71, + 1, + 75, + 1, + 79, + 1, + 85, + 1, + 91, + 1, + 97, + 1, + 103, + 1, + 109, + 1, + 115, + 1, + 121, + 1, + 126, + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 125))), + 1, + 27, + 91, + 51, + 74, + 0, + 27, + 91, + 50, + 32, + 113, + 0, + 27, + 91, + 37, + 112, + 49, + 37, + 100, + 32, + 113, + 0, + 27, + 91, + 49, + 59, + 50, + 65, + 0, + 27, + 79, + 120, + 0, + 27, + 79, + 116, + 0, + 27, + 79, + 118, + 0, + 27, + 79, + 114, + 0, + 27, + 79, + 69, + 0, + 27, + 79, + 107, + 0, + 27, + 79, + 108, + 0, + 27, + 79, + 111, + 0, + 27, + 79, + 110, + 0, + 27, + 79, + 106, + 0, + 27, + 79, + 109, + 0, + 27, + 79, + 112, + 0, + 65, + 88, + 0, + 88, + 84, + 0, + 67, + 114, + 0, + 67, + 115, + 0, + 69, + 51, + 0, + 77, + 115, + 0, + 83, + 101, + 0, + 83, + 115, + 0, + 88, + 77, + 0, + 107, + 68, + 67, + 51, + 0, + 107, + 68, + 67, + 52, + 0, + 107, + 68, + 67, + 53, + 0, + 107, + 68, + 67, + 54, + 0, + 107, + 68, + 67, + 55, + 0, + 107, + 68, + 78, + 0, + 107, + 68, + 78, + 51, + 0, + 107, + 68, + 78, + 52, + 0, + 107, + 68, + 78, + 53, + 0, + 107, + 68, + 78, + 54, + 0, + 107, + 68, + 78, + 55, + 0, + 107, + 69, + 78, + 68, + 51, + 0, + 107, + 69, + 78, + 68, + 52, + 0, + 107, + 69, + 78, + 68, + 53, + 0, + 107, + 69, + 78, + 68, + 54, + 0, + 107, + 69, + 78, + 68, + 55, + 0, + 107, + 72, + 79, + 77, + 51, + 0, + 107, + 72, + 79, + 77, + 52, + 0, + 107, + 72, + 79, + 77, + 53, + 0, + 107, + 72, + 79, + 77, + 54, + 0, + 107, + 72, + 79, + 77, + 55, + 0, + 107, + 73, + 67, + 51, + 0, + 107, + 73, + 67, + 52, + 0, + 107, + 73, + 67, + 53, + 0, + 107, + 73, + 67, + 54, + 0, + 107, + 73, + 67, + 55, + 0, + 107, + 76, + 70, + 84, + 51, + 0, + 107, + 76, + 70, + 84, + 52, + 0, + 107, + 76, + 70, + 84, + 53, + 0, + 107, + 76, + 70, + 84, + 54, + 0, + 107, + 76, + 70, + 84, + 55, + 0, + 107, + 78, + 88, + 84, + 51, + 0, + 107, + 78, + 88, + 84, + 52, + 0, + 107, + 78, + 88, + 84, + 53, + 0, + 107, + 78, + 88, + 84, + 54, + 0, + 107, + 78, + 88, + 84, + 55, + 0, + 107, + 80, + 82, + 86, + 51, + 0, + 107, + 80, + 82, + 86, + 52, + 0, + 107, + 80, + 82, + 86, + 53, + 0, + 107, + 80, + 82, + 86, + 54, + 0, + 107, + 80, + 82, + 86, + 55, + 0, + 107, + 82, + 73, + 84, + 51, + 0, + 107, + 82, + 73, + 84, + 52, + 0, + 107, + 82, + 73, + 84, + 53, + 0, + 107, + 82, + 73, + 84, + 54, + 0, + 107, + 82, + 73, + 84, + 55, + 0, + 107, + 85, + 80, + 0, + 107, + 85, + 80, + 51, + 0, + 107, + 85, + 80, + 52, + 0, + 107, + 85, + 80, + 53, + 0, + 107, + 85, + 80, + 54, + 0, + 107, + 85, + 80, + 55, + 0, + 107, + 97, + 50, + 0, + 107, + 98, + 49, + 0, + 107, + 98, + 51, + 0, + 107, + 99, + 50, + 0, + 107, + 112, + 53, + 0, + 107, + 112, + 65, + 68, + 68, + 0, + 107, + 112, + 67, + 77, + 65, + 0, + 107, + 112, + 68, + 73, + 86, + 0, + 107, + 112, + 68, + 79, + 84, + 0, + 107, + 112, + 77, + 85, + 76, + 0, + 107, + 112, + 83, + 85, + 66, + 0, + 107, + 112, + 90, + 82, + 79, + 0, + 114, + 109, + 120, + 120, + 0, + 115, + 109, + 120, + 120, + 0, + 120, + 109, + 0, +}; +pub const win32con_terminfo: [1530]i8 = [1530]i8{ + 26, + 1, + 52, + 0, + 15, + 0, + 15, + 0, + 125, + 1, + 106, + 2, + 119, + 105, + 110, + 51, + 50, + 99, + 111, + 110, + 124, + 65, + 78, + 83, + 73, + 32, + 101, + 109, + 117, + 108, + 97, + 116, + 105, + 111, + 110, + 32, + 102, + 111, + 114, + 32, + 108, + 105, + 98, + 117, + 118, + 32, + 111, + 110, + 32, + 108, + 101, + 103, + 97, + 99, + 121, + 32, + 99, + 111, + 110, + 115, + 111, + 108, + 101, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 1, + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 8, + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 8, + 0, + 64, + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 0, + 0, + 2, + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 4, + 0, + 11, + 0, + 15, + 0, + 19, + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 30, + 0, + 47, + 0, + 51, + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 55, + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 57, + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 61, + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 65, + 0, + 70, + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 79, + 0, + 84, + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 89, + 0, + 94, + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 107, + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 113, + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 115, + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 120, + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 124, + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 127))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 121))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 116))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 111))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 106))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 101))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 95))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 89))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 83))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 77))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 72))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 67))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 63))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 58))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 53))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 49))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 45))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 42))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 33))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 24))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 15))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 6))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 3))), + 0, + 8, + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 11, + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 49, + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 51, + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 55, + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 60, + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 62, + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 69, + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 76, + 1, + 83, + 1, + 90, + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 97, + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 104, + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 111, + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 118, + 1, + 124, + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 126))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 120))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 114))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 108))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 102))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 96))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 90))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 84))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 78))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 72))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 66))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 60))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 54))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 48))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 42))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 36))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 30))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 24))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 18))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 12))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 6))), + 1, + 0, + 2, + 6, + 2, + 12, + 2, + 18, + 2, + 24, + 2, + 30, + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 36, + 2, + 42, + 2, + 48, + 2, + 54, + 2, + 60, + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 66, + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 71, + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 80, + 2, + 90, + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 100, + 2, + 7, + 0, + 13, + 0, + 27, + 91, + 72, + 27, + 91, + 74, + 0, + 27, + 91, + 75, + 0, + 27, + 91, + 74, + 0, + 27, + 91, + 37, + 105, + 37, + 112, + 49, + 37, + 100, + 71, + 0, + 27, + 91, + 37, + 105, + 37, + 112, + 49, + 37, + 100, + 59, + 37, + 112, + 50, + 37, + 100, + 72, + 0, + 27, + 91, + 66, + 0, + 27, + 91, + 72, + 0, + 8, + 0, + 27, + 91, + 67, + 0, + 27, + 91, + 65, + 0, + 27, + 91, + 49, + 109, + 0, + 27, + 55, + 27, + 91, + 63, + 52, + 55, + 104, + 0, + 27, + 91, + 55, + 109, + 0, + 27, + 91, + 55, + 109, + 0, + 27, + 91, + 48, + 109, + 0, + 27, + 91, + 50, + 74, + 27, + 91, + 63, + 52, + 55, + 108, + 27, + 56, + 0, + 27, + 91, + 50, + 55, + 109, + 0, + 8, + 0, + 27, + 91, + 51, + 126, + 0, + 27, + 91, + 66, + 0, + 27, + 91, + 91, + 65, + 0, + 27, + 91, + 50, + 49, + 126, + 0, + 27, + 91, + 91, + 66, + 0, + 27, + 91, + 91, + 67, + 0, + 27, + 91, + 91, + 68, + 0, + 27, + 91, + 91, + 69, + 0, + 27, + 91, + 49, + 55, + 126, + 0, + 27, + 91, + 49, + 56, + 126, + 0, + 27, + 91, + 49, + 57, + 126, + 0, + 27, + 91, + 50, + 48, + 126, + 0, + 27, + 91, + 49, + 126, + 0, + 27, + 91, + 50, + 126, + 0, + 27, + 91, + 68, + 0, + 27, + 91, + 54, + 126, + 0, + 27, + 91, + 53, + 126, + 0, + 27, + 91, + 67, + 0, + 27, + 91, + 65, + 0, + 13, + 10, + 0, + 27, + 91, + 37, + 112, + 49, + 37, + 100, + 66, + 0, + 27, + 91, + 37, + 112, + 49, + 37, + 100, + 68, + 0, + 27, + 91, + 37, + 112, + 49, + 37, + 100, + 67, + 0, + 27, + 91, + 37, + 112, + 49, + 37, + 100, + 65, + 0, + 27, + 56, + 0, + 27, + 91, + 37, + 105, + 37, + 112, + 49, + 37, + 100, + 100, + 0, + 27, + 55, + 0, + 27, + 91, + 48, + 37, + 63, + 37, + 112, + 49, + 37, + 116, + 59, + 55, + 37, + 59, + 37, + 63, + 37, + 112, + 51, + 37, + 116, + 59, + 55, + 37, + 59, + 37, + 63, + 37, + 112, + 54, + 37, + 116, + 59, + 49, + 37, + 59, + 109, + 0, + 9, + 0, + 27, + 91, + 71, + 0, + 27, + 91, + 52, + 126, + 0, + 26, + 0, + 27, + 91, + 51, + 59, + 50, + 126, + 0, + 27, + 91, + 52, + 59, + 50, + 126, + 0, + 27, + 91, + 49, + 59, + 50, + 126, + 0, + 27, + 91, + 50, + 59, + 50, + 126, + 0, + 27, + 91, + 49, + 59, + 50, + 68, + 0, + 27, + 91, + 54, + 59, + 50, + 126, + 0, + 27, + 91, + 53, + 59, + 50, + 126, + 0, + 27, + 91, + 49, + 59, + 50, + 67, + 0, + 27, + 91, + 50, + 51, + 126, + 0, + 27, + 91, + 50, + 52, + 126, + 0, + 27, + 91, + 50, + 53, + 126, + 0, + 27, + 91, + 50, + 54, + 126, + 0, + 27, + 91, + 50, + 56, + 126, + 0, + 27, + 91, + 50, + 57, + 126, + 0, + 27, + 91, + 51, + 49, + 126, + 0, + 27, + 91, + 51, + 50, + 126, + 0, + 27, + 91, + 51, + 51, + 126, + 0, + 27, + 91, + 51, + 52, + 126, + 0, + 27, + 91, + 50, + 51, + 36, + 0, + 27, + 91, + 50, + 52, + 36, + 0, + 27, + 91, + 49, + 49, + 94, + 0, + 27, + 91, + 49, + 50, + 94, + 0, + 27, + 91, + 49, + 51, + 94, + 0, + 27, + 91, + 49, + 52, + 94, + 0, + 27, + 91, + 49, + 53, + 94, + 0, + 27, + 91, + 49, + 55, + 94, + 0, + 27, + 91, + 49, + 56, + 94, + 0, + 27, + 91, + 49, + 57, + 94, + 0, + 27, + 91, + 50, + 48, + 94, + 0, + 27, + 91, + 50, + 49, + 94, + 0, + 27, + 91, + 50, + 51, + 94, + 0, + 27, + 91, + 50, + 52, + 94, + 0, + 27, + 91, + 50, + 53, + 94, + 0, + 27, + 91, + 50, + 54, + 94, + 0, + 27, + 91, + 50, + 56, + 94, + 0, + 27, + 91, + 50, + 57, + 94, + 0, + 27, + 91, + 51, + 49, + 94, + 0, + 27, + 91, + 51, + 50, + 94, + 0, + 27, + 91, + 51, + 51, + 94, + 0, + 27, + 91, + 51, + 52, + 94, + 0, + 27, + 91, + 50, + 51, + 64, + 0, + 27, + 91, + 50, + 52, + 64, + 0, + 27, + 91, + 49, + 75, + 0, + 27, + 91, + 51, + 57, + 59, + 52, + 57, + 109, + 0, + 27, + 91, + 51, + 37, + 112, + 49, + 37, + 100, + 109, + 0, + 27, + 91, + 52, + 37, + 112, + 49, + 37, + 100, + 109, + 0, + 27, + 91, + 49, + 48, + 109, + 0, + 0, + 0, + 0, + 0, + 2, + 0, + 4, + 0, + 22, + 0, + 0, + 0, + 6, + 0, + 0, + 0, + 3, + 0, + 27, + 91, + 48, + 32, + 113, + 0, + 27, + 91, + 37, + 112, + 49, + 37, + 100, + 32, + 113, + 0, + 83, + 101, + 0, + 83, + 115, + 0, +}; +pub const xterm_256colour_terminfo: [3814]i8 = [3814]i8{ + 30, + 2, + 37, + 0, + 38, + 0, + 15, + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 99))), + 1, + 51, + 6, + 120, + 116, + 101, + 114, + 109, + 45, + 50, + 53, + 54, + 99, + 111, + 108, + 111, + 114, + 124, + 120, + 116, + 101, + 114, + 109, + 32, + 119, + 105, + 116, + 104, + 32, + 50, + 53, + 54, + 32, + 99, + 111, + 108, + 111, + 114, + 115, + 0, + 0, + 1, + 0, + 0, + 1, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 1, + 0, + 1, + 1, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 1, + 0, + 80, + 0, + 0, + 0, + 8, + 0, + 0, + 0, + 24, + 0, + 0, + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 0, + 1, + 0, + 0, + 0, + 0, + 1, + 0, + 0, + 0, + 4, + 0, + 6, + 0, + 8, + 0, + 25, + 0, + 30, + 0, + 38, + 0, + 42, + 0, + 46, + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 57, + 0, + 74, + 0, + 76, + 0, + 80, + 0, + 87, + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 89, + 0, + 102, + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 106, + 0, + 110, + 0, + 120, + 0, + 124, + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 128))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 124))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 119))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 114))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 96))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 91))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 86))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 81))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 76))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 71))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 66))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 57))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 53))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 46))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 28))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 23))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 17))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 11))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 7, + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 25, + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 29, + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 31, + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 36, + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 40, + 1, + 44, + 1, + 50, + 1, + 54, + 1, + 58, + 1, + 62, + 1, + 68, + 1, + 74, + 1, + 80, + 1, + 86, + 1, + 92, + 1, + 96, + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 101, + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 105, + 1, + 110, + 1, + 115, + 1, + 119, + 1, + 126, + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 123))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 119))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 111))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 103))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 94))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 85))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 82))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 73))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 64))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 55))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 46))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 37))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 28))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 19))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 10))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 8, + 2, + 12, + 2, + 17, + 2, + 22, + 2, + 42, + 2, + 51, + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 69, + 2, + 72, + 2, + 83, + 2, + 86, + 2, + 88, + 2, + 91, + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 72))), + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 69))), + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 67))), + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 63))), + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 59))), + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 55))), + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 51))), + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 47))), + 2, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 6, + 3, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 10, + 3, + 16, + 3, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 22, + 3, + 26, + 3, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 30, + 3, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 37, + 3, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 44, + 3, + 51, + 3, + 58, + 3, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 65, + 3, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 72, + 3, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 79, + 3, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 86, + 3, + 92, + 3, + 98, + 3, + 105, + 3, + 112, + 3, + 119, + 3, + 126, + 3, + @bitCast(i8, @truncate(i8, -@as(c_int, 122))), + 3, + @bitCast(i8, @truncate(i8, -@as(c_int, 114))), + 3, + @bitCast(i8, @truncate(i8, -@as(c_int, 106))), + 3, + @bitCast(i8, @truncate(i8, -@as(c_int, 98))), + 3, + @bitCast(i8, @truncate(i8, -@as(c_int, 90))), + 3, + @bitCast(i8, @truncate(i8, -@as(c_int, 82))), + 3, + @bitCast(i8, @truncate(i8, -@as(c_int, 74))), + 3, + @bitCast(i8, @truncate(i8, -@as(c_int, 66))), + 3, + @bitCast(i8, @truncate(i8, -@as(c_int, 59))), + 3, + @bitCast(i8, @truncate(i8, -@as(c_int, 52))), + 3, + @bitCast(i8, @truncate(i8, -@as(c_int, 45))), + 3, + @bitCast(i8, @truncate(i8, -@as(c_int, 38))), + 3, + @bitCast(i8, @truncate(i8, -@as(c_int, 30))), + 3, + @bitCast(i8, @truncate(i8, -@as(c_int, 22))), + 3, + @bitCast(i8, @truncate(i8, -@as(c_int, 14))), + 3, + @bitCast(i8, @truncate(i8, -@as(c_int, 6))), + 3, + 2, + 4, + 10, + 4, + 18, + 4, + 26, + 4, + 33, + 4, + 40, + 4, + 47, + 4, + 54, + 4, + 62, + 4, + 70, + 4, + 78, + 4, + 86, + 4, + 94, + 4, + 102, + 4, + 110, + 4, + 118, + 4, + 125, + 4, + @bitCast(i8, @truncate(i8, -@as(c_int, 124))), + 4, + @bitCast(i8, @truncate(i8, -@as(c_int, 117))), + 4, + @bitCast(i8, @truncate(i8, -@as(c_int, 110))), + 4, + @bitCast(i8, @truncate(i8, -@as(c_int, 102))), + 4, + @bitCast(i8, @truncate(i8, -@as(c_int, 94))), + 4, + @bitCast(i8, @truncate(i8, -@as(c_int, 86))), + 4, + @bitCast(i8, @truncate(i8, -@as(c_int, 78))), + 4, + @bitCast(i8, @truncate(i8, -@as(c_int, 70))), + 4, + @bitCast(i8, @truncate(i8, -@as(c_int, 62))), + 4, + @bitCast(i8, @truncate(i8, -@as(c_int, 54))), + 4, + @bitCast(i8, @truncate(i8, -@as(c_int, 46))), + 4, + @bitCast(i8, @truncate(i8, -@as(c_int, 39))), + 4, + @bitCast(i8, @truncate(i8, -@as(c_int, 32))), + 4, + @bitCast(i8, @truncate(i8, -@as(c_int, 25))), + 4, + @bitCast(i8, @truncate(i8, -@as(c_int, 20))), + 4, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 13))), + 4, + @bitCast(i8, @truncate(i8, -@as(c_int, 2))), + 4, + 3, + 5, + 22, + 5, + 26, + 5, + 35, + 5, + 42, + 5, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 120))), + 5, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 115))), + 5, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 109))), + 5, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 105))), + 5, + @bitCast(i8, @truncate(i8, -@as(c_int, 42))), + 5, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 22, + 6, + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + @bitCast(i8, @truncate(i8, -@as(c_int, 1))), + 45, + 6, + 48, + 6, + 27, + 91, + 90, + 0, + 7, + 0, + 13, + 0, + 27, + 91, + 37, + 105, + 37, + 112, + 49, + 37, + 100, + 59, + 37, + 112, + 50, + 37, + 100, + 114, + 0, + 27, + 91, + 51, + 103, + 0, + 27, + 91, + 72, + 27, + 91, + 50, + 74, + 0, + 27, + 91, + 75, + 0, + 27, + 91, + 74, + 0, + 27, + 91, + 37, + 105, + 37, + 112, + 49, + 37, + 100, + 71, + 0, + 27, + 91, + 37, + 105, + 37, + 112, + 49, + 37, + 100, + 59, + 37, + 112, + 50, + 37, + 100, + 72, + 0, + 10, + 0, + 27, + 91, + 72, + 0, + 27, + 91, + 63, + 50, + 53, + 108, + 0, + 8, + 0, + 27, + 91, + 63, + 49, + 50, + 108, + 27, + 91, + 63, + 50, + 53, + 104, + 0, + 27, + 91, + 67, + 0, + 27, + 91, + 65, + 0, + 27, + 91, + 63, + 49, + 50, + 59, + 50, + 53, + 104, + 0, + 27, + 91, + 80, + 0, + 27, + 91, + 77, + 0, + 27, + 40, + 48, + 0, + 27, + 91, + 53, + 109, + 0, + 27, + 91, + 49, + 109, + 0, + 27, + 91, + 63, + 49, + 48, + 52, + 57, + 104, + 27, + 91, + 50, + 50, + 59, + 48, + 59, + 48, + 116, + 0, + 27, + 91, + 50, + 109, + 0, + 27, + 91, + 52, + 104, + 0, + 27, + 91, + 56, + 109, + 0, + 27, + 91, + 55, + 109, + 0, + 27, + 91, + 55, + 109, + 0, + 27, + 91, + 52, + 109, + 0, + 27, + 91, + 37, + 112, + 49, + 37, + 100, + 88, + 0, + 27, + 40, + 66, + 0, + 27, + 40, + 66, + 27, + 91, + 109, + 0, + 27, + 91, + 63, + 49, + 48, + 52, + 57, + 108, + 27, + 91, + 50, + 51, + 59, + 48, + 59, + 48, + 116, + 0, + 27, + 91, + 52, + 108, + 0, + 27, + 91, + 50, + 55, + 109, + 0, + 27, + 91, + 50, + 52, + 109, + 0, + 27, + 91, + 63, + 53, + 104, + 36, + 60, + 49, + 48, + 48, + 47, + 62, + 27, + 91, + 63, + 53, + 108, + 0, + 27, + 91, + 33, + 112, + 27, + 91, + 63, + 51, + 59, + 52, + 108, + 27, + 91, + 52, + 108, + 27, + 62, + 0, + 27, + 91, + 76, + 0, + 8, + 0, + 27, + 91, + 51, + 126, + 0, + 27, + 79, + 66, + 0, + 27, + 79, + 80, + 0, + 27, + 91, + 50, + 49, + 126, + 0, + 27, + 79, + 81, + 0, + 27, + 79, + 82, + 0, + 27, + 79, + 83, + 0, + 27, + 91, + 49, + 53, + 126, + 0, + 27, + 91, + 49, + 55, + 126, + 0, + 27, + 91, + 49, + 56, + 126, + 0, + 27, + 91, + 49, + 57, + 126, + 0, + 27, + 91, + 50, + 48, + 126, + 0, + 27, + 79, + 72, + 0, + 27, + 91, + 50, + 126, + 0, + 27, + 79, + 68, + 0, + 27, + 91, + 54, + 126, + 0, + 27, + 91, + 53, + 126, + 0, + 27, + 79, + 67, + 0, + 27, + 91, + 49, + 59, + 50, + 66, + 0, + 27, + 91, + 49, + 59, + 50, + 65, + 0, + 27, + 79, + 65, + 0, + 27, + 91, + 63, + 49, + 108, + 27, + 62, + 0, + 27, + 91, + 63, + 49, + 104, + 27, + 61, + 0, + 27, + 91, + 63, + 49, + 48, + 51, + 52, + 108, + 0, + 27, + 91, + 63, + 49, + 48, + 51, + 52, + 104, + 0, + 27, + 69, + 0, + 27, + 91, + 37, + 112, + 49, + 37, + 100, + 80, + 0, + 27, + 91, + 37, + 112, + 49, + 37, + 100, + 77, + 0, + 27, + 91, + 37, + 112, + 49, + 37, + 100, + 66, + 0, + 27, + 91, + 37, + 112, + 49, + 37, + 100, + 64, + 0, + 27, + 91, + 37, + 112, + 49, + 37, + 100, + 83, + 0, + 27, + 91, + 37, + 112, + 49, + 37, + 100, + 76, + 0, + 27, + 91, + 37, + 112, + 49, + 37, + 100, + 68, + 0, + 27, + 91, + 37, + 112, + 49, + 37, + 100, + 67, + 0, + 27, + 91, + 37, + 112, + 49, + 37, + 100, + 84, + 0, + 27, + 91, + 37, + 112, + 49, + 37, + 100, + 65, + 0, + 27, + 91, + 105, + 0, + 27, + 91, + 52, + 105, + 0, + 27, + 91, + 53, + 105, + 0, + 37, + 112, + 49, + 37, + 99, + 27, + 91, + 37, + 112, + 50, + 37, + 123, + 49, + 125, + 37, + 45, + 37, + 100, + 98, + 0, + 27, + 99, + 27, + 93, + 49, + 48, + 52, + 7, + 0, + 27, + 91, + 33, + 112, + 27, + 91, + 63, + 51, + 59, + 52, + 108, + 27, + 91, + 52, + 108, + 27, + 62, + 0, + 27, + 56, + 0, + 27, + 91, + 37, + 105, + 37, + 112, + 49, + 37, + 100, + 100, + 0, + 27, + 55, + 0, + 10, + 0, + 27, + 77, + 0, + 37, + 63, + 37, + 112, + 57, + 37, + 116, + 27, + 40, + 48, + 37, + 101, + 27, + 40, + 66, + 37, + 59, + 27, + 91, + 48, + 37, + 63, + 37, + 112, + 54, + 37, + 116, + 59, + 49, + 37, + 59, + 37, + 63, + 37, + 112, + 53, + 37, + 116, + 59, + 50, + 37, + 59, + 37, + 63, + 37, + 112, + 50, + 37, + 116, + 59, + 52, + 37, + 59, + 37, + 63, + 37, + 112, + 49, + 37, + 112, + 51, + 37, + 124, + 37, + 116, + 59, + 55, + 37, + 59, + 37, + 63, + 37, + 112, + 52, + 37, + 116, + 59, + 53, + 37, + 59, + 37, + 63, + 37, + 112, + 55, + 37, + 116, + 59, + 56, + 37, + 59, + 109, + 0, + 27, + 72, + 0, + 9, + 0, + 27, + 79, + 119, + 0, + 27, + 79, + 121, + 0, + 27, + 79, + 117, + 0, + 27, + 79, + 113, + 0, + 27, + 79, + 115, + 0, + 96, + 96, + 97, + 97, + 102, + 102, + 103, + 103, + 105, + 105, + 106, + 106, + 107, + 107, + 108, + 108, + 109, + 109, + 110, + 110, + 111, + 111, + 112, + 112, + 113, + 113, + 114, + 114, + 115, + 115, + 116, + 116, + 117, + 117, + 118, + 118, + 119, + 119, + 120, + 120, + 121, + 121, + 122, + 122, + 123, + 123, + 124, + 124, + 125, + 125, + 126, + 126, + 0, + 27, + 91, + 90, + 0, + 27, + 91, + 63, + 55, + 104, + 0, + 27, + 91, + 63, + 55, + 108, + 0, + 27, + 79, + 70, + 0, + 27, + 79, + 77, + 0, + 27, + 91, + 51, + 59, + 50, + 126, + 0, + 27, + 91, + 49, + 59, + 50, + 70, + 0, + 27, + 91, + 49, + 59, + 50, + 72, + 0, + 27, + 91, + 50, + 59, + 50, + 126, + 0, + 27, + 91, + 49, + 59, + 50, + 68, + 0, + 27, + 91, + 54, + 59, + 50, + 126, + 0, + 27, + 91, + 53, + 59, + 50, + 126, + 0, + 27, + 91, + 49, + 59, + 50, + 67, + 0, + 27, + 91, + 50, + 51, + 126, + 0, + 27, + 91, + 50, + 52, + 126, + 0, + 27, + 91, + 49, + 59, + 50, + 80, + 0, + 27, + 91, + 49, + 59, + 50, + 81, + 0, + 27, + 91, + 49, + 59, + 50, + 82, + 0, + 27, + 91, + 49, + 59, + 50, + 83, + 0, + 27, + 91, + 49, + 53, + 59, + 50, + 126, + 0, + 27, + 91, + 49, + 55, + 59, + 50, + 126, + 0, + 27, + 91, + 49, + 56, + 59, + 50, + 126, + 0, + 27, + 91, + 49, + 57, + 59, + 50, + 126, + 0, + 27, + 91, + 50, + 48, + 59, + 50, + 126, + 0, + 27, + 91, + 50, + 49, + 59, + 50, + 126, + 0, + 27, + 91, + 50, + 51, + 59, + 50, + 126, + 0, + 27, + 91, + 50, + 52, + 59, + 50, + 126, + 0, + 27, + 91, + 49, + 59, + 53, + 80, + 0, + 27, + 91, + 49, + 59, + 53, + 81, + 0, + 27, + 91, + 49, + 59, + 53, + 82, + 0, + 27, + 91, + 49, + 59, + 53, + 83, + 0, + 27, + 91, + 49, + 53, + 59, + 53, + 126, + 0, + 27, + 91, + 49, + 55, + 59, + 53, + 126, + 0, + 27, + 91, + 49, + 56, + 59, + 53, + 126, + 0, + 27, + 91, + 49, + 57, + 59, + 53, + 126, + 0, + 27, + 91, + 50, + 48, + 59, + 53, + 126, + 0, + 27, + 91, + 50, + 49, + 59, + 53, + 126, + 0, + 27, + 91, + 50, + 51, + 59, + 53, + 126, + 0, + 27, + 91, + 50, + 52, + 59, + 53, + 126, + 0, + 27, + 91, + 49, + 59, + 54, + 80, + 0, + 27, + 91, + 49, + 59, + 54, + 81, + 0, + 27, + 91, + 49, + 59, + 54, + 82, + 0, + 27, + 91, + 49, + 59, + 54, + 83, + 0, + 27, + 91, + 49, + 53, + 59, + 54, + 126, + 0, + 27, + 91, + 49, + 55, + 59, + 54, + 126, + 0, + 27, + 91, + 49, + 56, + 59, + 54, + 126, + 0, + 27, + 91, + 49, + 57, + 59, + 54, + 126, + 0, + 27, + 91, + 50, + 48, + 59, + 54, + 126, + 0, + 27, + 91, + 50, + 49, + 59, + 54, + 126, + 0, + 27, + 91, + 50, + 51, + 59, + 54, + 126, + 0, + 27, + 91, + 50, + 52, + 59, + 54, + 126, + 0, + 27, + 91, + 49, + 59, + 51, + 80, + 0, + 27, + 91, + 49, + 59, + 51, + 81, + 0, + 27, + 91, + 49, + 59, + 51, + 82, + 0, + 27, + 91, + 49, + 59, + 51, + 83, + 0, + 27, + 91, + 49, + 53, + 59, + 51, + 126, + 0, + 27, + 91, + 49, + 55, + 59, + 51, + 126, + 0, + 27, + 91, + 49, + 56, + 59, + 51, + 126, + 0, + 27, + 91, + 49, + 57, + 59, + 51, + 126, + 0, + 27, + 91, + 50, + 48, + 59, + 51, + 126, + 0, + 27, + 91, + 50, + 49, + 59, + 51, + 126, + 0, + 27, + 91, + 50, + 51, + 59, + 51, + 126, + 0, + 27, + 91, + 50, + 52, + 59, + 51, + 126, + 0, + 27, + 91, + 49, + 59, + 52, + 80, + 0, + 27, + 91, + 49, + 59, + 52, + 81, + 0, + 27, + 91, + 49, + 59, + 52, + 82, + 0, + 27, + 91, + 49, + 75, + 0, + 27, + 91, + 63, + 54, + 57, + 108, + 0, + 27, + 91, + 37, + 105, + 37, + 100, + 59, + 37, + 100, + 82, + 0, + 27, + 91, + 54, + 110, + 0, + 27, + 91, + 63, + 37, + 91, + 59, + 48, + 49, + 50, + 51, + 52, + 53, + 54, + 55, + 56, + 57, + 93, + 99, + 0, + 27, + 91, + 99, + 0, + 27, + 91, + 51, + 57, + 59, + 52, + 57, + 109, + 0, + 27, + 93, + 49, + 48, + 52, + 7, + 0, + 27, + 93, + 52, + 59, + 37, + 112, + 49, + 37, + 100, + 59, + 114, + 103, + 98, + 58, + 37, + 112, + 50, + 37, + 123, + 50, + 53, + 53, + 125, + 37, + 42, + 37, + 123, + 49, + 48, + 48, + 48, + 125, + 37, + 47, + 37, + 50, + 46, + 50, + 88, + 47, + 37, + 112, + 51, + 37, + 123, + 50, + 53, + 53, + 125, + 37, + 42, + 37, + 123, + 49, + 48, + 48, + 48, + 125, + 37, + 47, + 37, + 50, + 46, + 50, + 88, + 47, + 37, + 112, + 52, + 37, + 123, + 50, + 53, + 53, + 125, + 37, + 42, + 37, + 123, + 49, + 48, + 48, + 48, + 125, + 37, + 47, + 37, + 50, + 46, + 50, + 88, + 27, + 92, + 0, + 27, + 91, + 51, + 109, + 0, + 27, + 91, + 50, + 51, + 109, + 0, + 27, + 91, + 60, + 0, + 27, + 91, + 37, + 63, + 37, + 112, + 49, + 37, + 123, + 56, + 125, + 37, + 60, + 37, + 116, + 51, + 37, + 112, + 49, + 37, + 100, + 37, + 101, + 37, + 112, + 49, + 37, + 123, + 49, + 54, + 125, + 37, + 60, + 37, + 116, + 57, + 37, + 112, + 49, + 37, + 123, + 56, + 125, + 37, + 45, + 37, + 100, + 37, + 101, + 51, + 56, + 59, + 53, + 59, + 37, + 112, + 49, + 37, + 100, + 37, + 59, + 109, + 0, + 27, + 91, + 37, + 63, + 37, + 112, + 49, + 37, + 123, + 56, + 125, + 37, + 60, + 37, + 116, + 52, + 37, + 112, + 49, + 37, + 100, + 37, + 101, + 37, + 112, + 49, + 37, + 123, + 49, + 54, + 125, + 37, + 60, + 37, + 116, + 49, + 48, + 37, + 112, + 49, + 37, + 123, + 56, + 125, + 37, + 45, + 37, + 100, + 37, + 101, + 52, + 56, + 59, + 53, + 59, + 37, + 112, + 49, + 37, + 100, + 37, + 59, + 109, + 0, + 27, + 91, + 63, + 54, + 57, + 104, + 27, + 91, + 37, + 105, + 37, + 112, + 49, + 37, + 100, + 59, + 37, + 112, + 50, + 37, + 100, + 115, + 0, + 27, + 108, + 0, + 27, + 109, + 0, + 0, + 2, + 0, + 0, + 0, + 74, + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 106))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 84))), + 3, + 1, + 1, + 0, + 0, + 7, + 0, + 19, + 0, + 24, + 0, + 42, + 0, + 48, + 0, + 58, + 0, + 90, + 0, + 97, + 0, + 104, + 0, + 111, + 0, + 118, + 0, + 125, + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 124))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 117))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 110))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 103))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 96))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 89))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 82))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 75))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 68))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 61))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 54))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 47))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 40))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 33))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 26))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 19))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 12))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 5))), + 0, + 2, + 1, + 9, + 1, + 16, + 1, + 23, + 1, + 30, + 1, + 37, + 1, + 44, + 1, + 51, + 1, + 58, + 1, + 65, + 1, + 72, + 1, + 79, + 1, + 86, + 1, + 93, + 1, + 100, + 1, + 107, + 1, + 114, + 1, + 121, + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 128))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 121))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 114))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 107))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 100))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 93))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 86))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 79))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 72))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 65))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 58))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 54))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 50))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 46))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 42))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 38))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 34))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 30))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 26))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 22))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 18))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 14))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 10))), + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 4))), + 1, + 1, + 2, + 0, + 0, + 3, + 0, + 6, + 0, + 9, + 0, + 12, + 0, + 15, + 0, + 18, + 0, + 21, + 0, + 24, + 0, + 27, + 0, + 32, + 0, + 37, + 0, + 42, + 0, + 47, + 0, + 52, + 0, + 56, + 0, + 61, + 0, + 66, + 0, + 71, + 0, + 76, + 0, + 81, + 0, + 87, + 0, + 93, + 0, + 99, + 0, + 105, + 0, + 111, + 0, + 117, + 0, + 123, + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 127))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 121))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 115))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 110))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 105))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 100))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 95))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 90))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 84))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 78))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 72))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 66))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 60))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 54))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 48))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 42))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 36))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 30))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 24))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 18))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 12))), + 0, + @bitCast(i8, @truncate(i8, -@as(c_int, 6))), + 0, + 0, + 1, + 6, + 1, + 12, + 1, + 18, + 1, + 24, + 1, + 30, + 1, + 34, + 1, + 39, + 1, + 44, + 1, + 49, + 1, + 54, + 1, + 59, + 1, + 63, + 1, + 67, + 1, + 71, + 1, + 75, + 1, + 79, + 1, + 85, + 1, + 91, + 1, + 97, + 1, + 103, + 1, + 109, + 1, + 115, + 1, + 121, + 1, + 126, + 1, + @bitCast(i8, @truncate(i8, -@as(c_int, 125))), + 1, + 27, + 93, + 49, + 49, + 50, + 7, + 0, + 27, + 93, + 49, + 50, + 59, + 37, + 112, + 49, + 37, + 115, + 7, + 0, + 27, + 91, + 51, + 74, + 0, + 27, + 93, + 53, + 50, + 59, + 37, + 112, + 49, + 37, + 115, + 59, + 37, + 112, + 50, + 37, + 115, + 7, + 0, + 27, + 91, + 50, + 32, + 113, + 0, + 27, + 91, + 37, + 112, + 49, + 37, + 100, + 32, + 113, + 0, + 27, + 91, + 63, + 49, + 48, + 48, + 54, + 59, + 49, + 48, + 48, + 48, + 37, + 63, + 37, + 112, + 49, + 37, + 123, + 49, + 125, + 37, + 61, + 37, + 116, + 104, + 37, + 101, + 108, + 37, + 59, + 0, + 27, + 91, + 51, + 59, + 51, + 126, + 0, + 27, + 91, + 51, + 59, + 52, + 126, + 0, + 27, + 91, + 51, + 59, + 53, + 126, + 0, + 27, + 91, + 51, + 59, + 54, + 126, + 0, + 27, + 91, + 51, + 59, + 55, + 126, + 0, + 27, + 91, + 49, + 59, + 50, + 66, + 0, + 27, + 91, + 49, + 59, + 51, + 66, + 0, + 27, + 91, + 49, + 59, + 52, + 66, + 0, + 27, + 91, + 49, + 59, + 53, + 66, + 0, + 27, + 91, + 49, + 59, + 54, + 66, + 0, + 27, + 91, + 49, + 59, + 55, + 66, + 0, + 27, + 91, + 49, + 59, + 51, + 70, + 0, + 27, + 91, + 49, + 59, + 52, + 70, + 0, + 27, + 91, + 49, + 59, + 53, + 70, + 0, + 27, + 91, + 49, + 59, + 54, + 70, + 0, + 27, + 91, + 49, + 59, + 55, + 70, + 0, + 27, + 91, + 49, + 59, + 51, + 72, + 0, + 27, + 91, + 49, + 59, + 52, + 72, + 0, + 27, + 91, + 49, + 59, + 53, + 72, + 0, + 27, + 91, + 49, + 59, + 54, + 72, + 0, + 27, + 91, + 49, + 59, + 55, + 72, + 0, + 27, + 91, + 50, + 59, + 51, + 126, + 0, + 27, + 91, + 50, + 59, + 52, + 126, + 0, + 27, + 91, + 50, + 59, + 53, + 126, + 0, + 27, + 91, + 50, + 59, + 54, + 126, + 0, + 27, + 91, + 50, + 59, + 55, + 126, + 0, + 27, + 91, + 49, + 59, + 51, + 68, + 0, + 27, + 91, + 49, + 59, + 52, + 68, + 0, + 27, + 91, + 49, + 59, + 53, + 68, + 0, + 27, + 91, + 49, + 59, + 54, + 68, + 0, + 27, + 91, + 49, + 59, + 55, + 68, + 0, + 27, + 91, + 54, + 59, + 51, + 126, + 0, + 27, + 91, + 54, + 59, + 52, + 126, + 0, + 27, + 91, + 54, + 59, + 53, + 126, + 0, + 27, + 91, + 54, + 59, + 54, + 126, + 0, + 27, + 91, + 54, + 59, + 55, + 126, + 0, + 27, + 91, + 53, + 59, + 51, + 126, + 0, + 27, + 91, + 53, + 59, + 52, + 126, + 0, + 27, + 91, + 53, + 59, + 53, + 126, + 0, + 27, + 91, + 53, + 59, + 54, + 126, + 0, + 27, + 91, + 53, + 59, + 55, + 126, + 0, + 27, + 91, + 49, + 59, + 51, + 67, + 0, + 27, + 91, + 49, + 59, + 52, + 67, + 0, + 27, + 91, + 49, + 59, + 53, + 67, + 0, + 27, + 91, + 49, + 59, + 54, + 67, + 0, + 27, + 91, + 49, + 59, + 55, + 67, + 0, + 27, + 91, + 49, + 59, + 50, + 65, + 0, + 27, + 91, + 49, + 59, + 51, + 65, + 0, + 27, + 91, + 49, + 59, + 52, + 65, + 0, + 27, + 91, + 49, + 59, + 53, + 65, + 0, + 27, + 91, + 49, + 59, + 54, + 65, + 0, + 27, + 91, + 49, + 59, + 55, + 65, + 0, + 27, + 79, + 120, + 0, + 27, + 79, + 116, + 0, + 27, + 79, + 118, + 0, + 27, + 79, + 114, + 0, + 27, + 79, + 69, + 0, + 27, + 79, + 107, + 0, + 27, + 79, + 108, + 0, + 27, + 79, + 111, + 0, + 27, + 79, + 110, + 0, + 27, + 79, + 106, + 0, + 27, + 79, + 109, + 0, + 27, + 79, + 112, + 0, + 27, + 91, + 50, + 57, + 109, + 0, + 27, + 91, + 57, + 109, + 0, + 27, + 91, + 60, + 37, + 105, + 37, + 112, + 51, + 37, + 100, + 59, + 37, + 112, + 49, + 37, + 100, + 59, + 37, + 112, + 50, + 37, + 100, + 59, + 37, + 63, + 37, + 112, + 52, + 37, + 116, + 77, + 37, + 101, + 109, + 37, + 59, + 0, + 65, + 88, + 0, + 88, + 84, + 0, + 67, + 114, + 0, + 67, + 115, + 0, + 69, + 51, + 0, + 77, + 115, + 0, + 83, + 101, + 0, + 83, + 115, + 0, + 88, + 77, + 0, + 107, + 68, + 67, + 51, + 0, + 107, + 68, + 67, + 52, + 0, + 107, + 68, + 67, + 53, + 0, + 107, + 68, + 67, + 54, + 0, + 107, + 68, + 67, + 55, + 0, + 107, + 68, + 78, + 0, + 107, + 68, + 78, + 51, + 0, + 107, + 68, + 78, + 52, + 0, + 107, + 68, + 78, + 53, + 0, + 107, + 68, + 78, + 54, + 0, + 107, + 68, + 78, + 55, + 0, + 107, + 69, + 78, + 68, + 51, + 0, + 107, + 69, + 78, + 68, + 52, + 0, + 107, + 69, + 78, + 68, + 53, + 0, + 107, + 69, + 78, + 68, + 54, + 0, + 107, + 69, + 78, + 68, + 55, + 0, + 107, + 72, + 79, + 77, + 51, + 0, + 107, + 72, + 79, + 77, + 52, + 0, + 107, + 72, + 79, + 77, + 53, + 0, + 107, + 72, + 79, + 77, + 54, + 0, + 107, + 72, + 79, + 77, + 55, + 0, + 107, + 73, + 67, + 51, + 0, + 107, + 73, + 67, + 52, + 0, + 107, + 73, + 67, + 53, + 0, + 107, + 73, + 67, + 54, + 0, + 107, + 73, + 67, + 55, + 0, + 107, + 76, + 70, + 84, + 51, + 0, + 107, + 76, + 70, + 84, + 52, + 0, + 107, + 76, + 70, + 84, + 53, + 0, + 107, + 76, + 70, + 84, + 54, + 0, + 107, + 76, + 70, + 84, + 55, + 0, + 107, + 78, + 88, + 84, + 51, + 0, + 107, + 78, + 88, + 84, + 52, + 0, + 107, + 78, + 88, + 84, + 53, + 0, + 107, + 78, + 88, + 84, + 54, + 0, + 107, + 78, + 88, + 84, + 55, + 0, + 107, + 80, + 82, + 86, + 51, + 0, + 107, + 80, + 82, + 86, + 52, + 0, + 107, + 80, + 82, + 86, + 53, + 0, + 107, + 80, + 82, + 86, + 54, + 0, + 107, + 80, + 82, + 86, + 55, + 0, + 107, + 82, + 73, + 84, + 51, + 0, + 107, + 82, + 73, + 84, + 52, + 0, + 107, + 82, + 73, + 84, + 53, + 0, + 107, + 82, + 73, + 84, + 54, + 0, + 107, + 82, + 73, + 84, + 55, + 0, + 107, + 85, + 80, + 0, + 107, + 85, + 80, + 51, + 0, + 107, + 85, + 80, + 52, + 0, + 107, + 85, + 80, + 53, + 0, + 107, + 85, + 80, + 54, + 0, + 107, + 85, + 80, + 55, + 0, + 107, + 97, + 50, + 0, + 107, + 98, + 49, + 0, + 107, + 98, + 51, + 0, + 107, + 99, + 50, + 0, + 107, + 112, + 53, + 0, + 107, + 112, + 65, + 68, + 68, + 0, + 107, + 112, + 67, + 77, + 65, + 0, + 107, + 112, + 68, + 73, + 86, + 0, + 107, + 112, + 68, + 79, + 84, + 0, + 107, + 112, + 77, + 85, + 76, + 0, + 107, + 112, + 83, + 85, + 66, + 0, + 107, + 112, + 90, + 82, + 79, + 0, + 114, + 109, + 120, + 120, + 0, + 115, + 109, + 120, + 120, + 0, + 120, + 109, + 0, +}; +pub const struct_ucell = extern struct { + data: [30]u8, + attr: sattr_T, +}; +pub const UCell = struct_ucell; +pub const struct_ugrid = extern struct { + row: c_int, + col: c_int, + width: c_int, + height: c_int, + cells: [*c][*c]UCell, +}; +pub const UGrid = struct_ugrid; +pub extern fn ugrid_init(grid: [*c]UGrid) void; +pub extern fn ugrid_free(grid: [*c]UGrid) void; +pub extern fn ugrid_resize(grid: [*c]UGrid, width: c_int, height: c_int) void; +pub extern fn ugrid_clear(grid: [*c]UGrid) void; +pub extern fn ugrid_clear_chunk(grid: [*c]UGrid, row: c_int, col: c_int, endcol: c_int, attr: sattr_T) void; +pub extern fn ugrid_goto(grid: [*c]UGrid, row: c_int, col: c_int) void; +pub extern fn ugrid_scroll(grid: [*c]UGrid, top: c_int, bot: c_int, left: c_int, right: c_int, count: c_int) void; +pub extern fn ui_comp_init() void; +pub extern fn ui_comp_syn_init() void; +pub extern fn ui_comp_attach(ui: [*c]UI) void; +pub extern fn ui_comp_detach(ui: [*c]UI) void; +pub extern fn ui_comp_should_draw() bool; +pub extern fn ui_comp_put_grid(grid: [*c]ScreenGrid, row: c_int, col: c_int, height: c_int, width: c_int, valid: bool, on_top: bool) bool; +pub extern fn ui_comp_remove_grid(grid: [*c]ScreenGrid) void; +pub extern fn ui_comp_set_grid(handle: handle_T) bool; +pub extern fn ui_comp_raise_grid(grid: [*c]ScreenGrid, new_index: usize) void; +pub extern fn ui_comp_grid_cursor_goto(grid_handle: Integer, r: Integer, c: Integer) void; +pub extern fn ui_comp_mouse_focus(row: c_int, col: c_int) [*c]ScreenGrid; +pub extern fn ui_comp_get_grid_at_coord(row: c_int, col: c_int) [*c]ScreenGrid; +pub extern fn ui_comp_compose_grid(grid: [*c]ScreenGrid) void; +pub extern fn ui_comp_raw_line(grid: Integer, row: Integer, startcol: Integer, endcol: Integer, clearcol: Integer, clearattr: Integer, flags: LineFlags, chunk: [*c]const schar_T, attrs: [*c]const sattr_T) void; +pub extern fn ui_comp_set_screen_valid(valid: bool) bool; +pub extern fn ui_comp_msg_set_pos(grid: Integer, row: Integer, scrolled: Boolean, sep_char: String) void; +pub extern fn ui_comp_grid_scroll(grid: Integer, top: Integer, bot: Integer, left: Integer, right: Integer, rows: Integer, cols: Integer) void; +pub extern fn ui_comp_grid_resize(grid: Integer, width: Integer, height: Integer) void; +pub extern fn u_save_cursor() c_int; +pub extern fn u_save(top: linenr_T, bot: linenr_T) c_int; +pub extern fn u_savesub(lnum: linenr_T) c_int; +pub extern fn u_inssub(lnum: linenr_T) c_int; +pub extern fn u_savedel(lnum: linenr_T, nlines: c_long) c_int; +pub extern fn undo_allowed(buf: [*c]buf_T) bool; +pub extern fn u_savecommon(buf: [*c]buf_T, top: linenr_T, bot: linenr_T, newbot: linenr_T, reload: c_int) c_int; +pub extern fn u_compute_hash(buf: [*c]buf_T, hash: [*c]u8) void; +pub extern fn u_get_undo_file_name(buf_ffname: [*c]const u8, reading: bool) [*c]u8; +pub extern fn u_write_undo(name: [*c]const u8, forceit: bool, buf: [*c]buf_T, hash: [*c]u8) void; +pub extern fn u_read_undo(name: [*c]u8, hash: [*c]const u8, orig_name: [*c]const u8) void; +pub extern fn u_undo(count: c_int) void; +pub extern fn u_redo(count: c_int) void; +pub extern fn u_undo_and_forget(count: c_int, do_buf_event: bool) bool; +pub extern fn undo_time(step: c_long, sec: bool, file: bool, absolute: bool) void; +pub extern fn undo_fmt_time(buf: [*c]u8, buflen: usize, tt: time_t) void; +pub extern fn u_sync(force: bool) void; +pub extern fn ex_undolist(eap: [*c]exarg_T) void; +pub extern fn ex_undojoin(eap: [*c]exarg_T) void; +pub extern fn u_unchanged(buf: [*c]buf_T) void; +pub extern fn u_find_first_changed() void; +pub extern fn u_update_save_nr(buf: [*c]buf_T) void; +pub extern fn u_clearall(buf: [*c]buf_T) void; +pub extern fn u_saveline(lnum: linenr_T) void; +pub extern fn u_clearline() void; +pub extern fn u_undoline() void; +pub extern fn u_blockfree(buf: [*c]buf_T) void; +pub extern fn bufIsChanged(buf: [*c]buf_T) bool; +pub extern fn anyBufIsChanged() bool; +pub extern fn curbufIsChanged() bool; +pub extern fn u_eval_tree(first_uhp: [*c]const u_header_T) [*c]list_T; +pub extern fn u_force_get_undo_header(buf: [*c]buf_T) [*c]u_header_T; +pub extern var Version: [*c]u8; +pub extern var longVersion: [*c]u8; +pub extern fn has_nvim_version(version_str: [*c]const u8) bool; +pub extern fn has_vim_patch(n: c_int) bool; +pub extern fn version_dict() Dictionary; +pub extern fn ex_version(eap: [*c]exarg_T) void; +pub extern fn list_in_columns(items: [*c][*c]u8, size: c_int, current: c_int) void; +pub extern fn list_lua_version() void; +pub extern fn list_version() void; +pub extern fn maybe_intro_message() void; +pub extern fn intro_message(colon: c_int) void; +pub extern fn ex_intro(eap: [*c]exarg_T) void; +pub const ParserLine = extern struct { + data: [*c]const u8, + size: usize, + allocated: bool, +}; +pub const ParserLineGetter = ?*const fn (?*anyopaque, [*c]ParserLine) callconv(.C) void; +pub const ParserPosition = extern struct { + line: usize, + col: usize, +}; +pub const kPTopStateParsingCommand: c_int = 0; +pub const kPTopStateParsingExpression: c_int = 1; +const enum_unnamed_157 = c_uint; +pub const kExprUnknown: c_int = 0; +const enum_unnamed_160 = c_uint; +const struct_unnamed_159 = extern struct { + type: enum_unnamed_160, +}; +const union_unnamed_158 = extern union { + expr: struct_unnamed_159, +}; +pub const ParserStateItem = extern struct { + type: enum_unnamed_157, + data: union_unnamed_158, +}; +const struct_unnamed_161 = extern struct { + size: usize, + capacity: usize, + items: [*c]ParserLine, + init_array: [4]ParserLine, +}; +pub const ParserInputReader = extern struct { + get_line: ParserLineGetter, + cookie: ?*anyopaque, + lines: struct_unnamed_161, + conv: vimconv_T, +}; +pub const ParserHighlightChunk = extern struct { + start: ParserPosition, + end_col: usize, + group: [*c]const u8, +}; +pub const ParserHighlight = extern struct { + size: usize, + capacity: usize, + items: [*c]ParserHighlightChunk, + init_array: [16]ParserHighlightChunk, +}; +const struct_unnamed_162 = extern struct { + size: usize, + capacity: usize, + items: [*c]ParserStateItem, + init_array: [16]ParserStateItem, +}; +pub const ParserState = extern struct { + reader: ParserInputReader, + pos: ParserPosition, + stack: struct_unnamed_162, + colors: [*c]ParserHighlight, + can_continuate: bool, +}; +pub inline fn viml_parser_init(ret_pstate: [*c]ParserState, get_line: ParserLineGetter, cookie: ?*anyopaque, colors: [*c]ParserHighlight) void { + ret_pstate.* = ParserState{ + .reader = ParserInputReader{ + .get_line = get_line, + .cookie = cookie, + .lines = @import("std").mem.zeroes(struct_unnamed_161), + .conv = vimconv_T{ + .vc_type = CONV_NONE, + .vc_factor = @as(c_int, 1), + .vc_fd = @import("std").mem.zeroes(iconv_t), + .vc_fail = @as(c_int, 0) != 0, + }, + }, + .pos = ParserPosition{ + .line = @bitCast(usize, @as(c_long, @as(c_int, 0))), + .col = @bitCast(usize, @as(c_long, @as(c_int, 0))), + }, + .stack = @import("std").mem.zeroes(struct_unnamed_162), + .colors = colors, + .can_continuate = @as(c_int, 0) != 0, + }; + _ = blk: { + _ = blk_1: { + ret_pstate.*.reader.lines.capacity = (@sizeOf([4]ParserLine) / @sizeOf(ParserLine)) / @bitCast(usize, @as(c_long, @boolToInt(!((@sizeOf([4]ParserLine) % @sizeOf(ParserLine)) != 0)))); + break :blk_1 blk_2: { + const tmp = @bitCast(usize, @as(c_long, @as(c_int, 0))); + ret_pstate.*.reader.lines.size = tmp; + break :blk_2 tmp; + }; + }; + break :blk blk_1: { + const tmp = @ptrCast([*c]ParserLine, @alignCast(@import("std").meta.alignment([*c]ParserLine), &ret_pstate.*.reader.lines.init_array)); + ret_pstate.*.reader.lines.items = tmp; + break :blk_1 tmp; + }; + }; + _ = blk: { + _ = blk_1: { + ret_pstate.*.stack.capacity = (@sizeOf([16]ParserStateItem) / @sizeOf(ParserStateItem)) / @bitCast(usize, @as(c_long, @boolToInt(!((@sizeOf([16]ParserStateItem) % @sizeOf(ParserStateItem)) != 0)))); + break :blk_1 blk_2: { + const tmp = @bitCast(usize, @as(c_long, @as(c_int, 0))); + ret_pstate.*.stack.size = tmp; + break :blk_2 tmp; + }; + }; + break :blk blk_1: { + const tmp = @ptrCast([*c]ParserStateItem, @alignCast(@import("std").meta.alignment([*c]ParserStateItem), &ret_pstate.*.stack.init_array)); + ret_pstate.*.stack.items = tmp; + break :blk_1 tmp; + }; + }; +} +pub inline fn viml_parser_destroy(pstate: [*c]ParserState) void { + { + var i: usize = 0; + while (i < pstate.*.reader.lines.size) : (i +%= 1) { + var pline: ParserLine = pstate.*.reader.lines.items[i]; + if (pline.allocated) { + xfree(@intToPtr(?*anyopaque, @ptrToInt(pline.data))); + } + } + } + while (true) { + if (pstate.*.reader.lines.items != @ptrCast([*c]ParserLine, @alignCast(@import("std").meta.alignment([*c]ParserLine), &pstate.*.reader.lines.init_array))) { + while (true) { + var ptr_: [*c]?*anyopaque = @ptrCast([*c]?*anyopaque, @alignCast(@import("std").meta.alignment([*c]?*anyopaque), &pstate.*.reader.lines.items)); + xfree(ptr_.*); + ptr_.* = @intToPtr(?*anyopaque, @as(c_int, 0)); + _ = ptr_.*; + if (!false) break; + } + } + if (!false) break; + } + while (true) { + if (pstate.*.stack.items != @ptrCast([*c]ParserStateItem, @alignCast(@import("std").meta.alignment([*c]ParserStateItem), &pstate.*.stack.init_array))) { + while (true) { + var ptr_: [*c]?*anyopaque = @ptrCast([*c]?*anyopaque, @alignCast(@import("std").meta.alignment([*c]?*anyopaque), &pstate.*.stack.items)); + xfree(ptr_.*); + ptr_.* = @intToPtr(?*anyopaque, @as(c_int, 0)); + _ = ptr_.*; + if (!false) break; + } + } + if (!false) break; + } +} +pub fn viml_preader_get_line(preader: [*c]ParserInputReader, ret_pline: [*c]ParserLine) callconv(.C) void { + var pline: ParserLine = undefined; + preader.*.get_line.?(preader.*.cookie, &pline); + if ((preader.*.conv.vc_type != CONV_NONE) and (pline.size != 0)) { + var cpline: ParserLine = ParserLine{ + .data = null, + .size = pline.size, + .allocated = @as(c_int, 1) != 0, + }; + cpline.data = string_convert(&preader.*.conv, @intToPtr([*c]u8, @ptrToInt(pline.data)), &cpline.size); + if (pline.allocated) { + xfree(@intToPtr(?*anyopaque, @ptrToInt(pline.data))); + } + pline = cpline; + } + _ = blk: { + const tmp = pline; + (blk_1: { + _ = if (preader.*.lines.size == preader.*.lines.capacity) blk_2: { + _ = blk_3: { + preader.*.lines.capacity = if ((preader.*.lines.capacity << @intCast(@import("std").math.Log2Int(usize), 1)) > ((@sizeOf([4]ParserLine) / @sizeOf(ParserLine)) / @bitCast(usize, @as(c_long, @boolToInt(!((@sizeOf([4]ParserLine) % @sizeOf(ParserLine)) != 0)))))) preader.*.lines.capacity << @intCast(@import("std").math.Log2Int(usize), 1) else (@sizeOf([4]ParserLine) / @sizeOf(ParserLine)) / @bitCast(usize, @as(c_long, @boolToInt(!((@sizeOf([4]ParserLine) % @sizeOf(ParserLine)) != 0)))); + break :blk_3 blk_4: { + const tmp_5 = @ptrCast([*c]ParserLine, @alignCast(@import("std").meta.alignment([*c]ParserLine), if (preader.*.lines.capacity == ((@sizeOf([4]ParserLine) / @sizeOf(ParserLine)) / @bitCast(usize, @as(c_long, @boolToInt(!((@sizeOf([4]ParserLine) % @sizeOf(ParserLine)) != 0)))))) if (preader.*.lines.items == @ptrCast([*c]ParserLine, @alignCast(@import("std").meta.alignment([*c]ParserLine), &preader.*.lines.init_array))) @ptrCast(?*anyopaque, preader.*.lines.items) else _memcpy_free(@ptrCast(?*anyopaque, @ptrCast([*c]ParserLine, @alignCast(@import("std").meta.alignment([*c]ParserLine), &preader.*.lines.init_array))), @ptrCast(?*anyopaque, preader.*.lines.items), preader.*.lines.size *% @sizeOf(ParserLine)) else if (preader.*.lines.items == @ptrCast([*c]ParserLine, @alignCast(@import("std").meta.alignment([*c]ParserLine), &preader.*.lines.init_array))) memcpy(xmalloc(preader.*.lines.capacity *% @sizeOf(ParserLine)), @ptrCast(?*const anyopaque, preader.*.lines.items), preader.*.lines.size *% @sizeOf(ParserLine)) else xrealloc(@ptrCast(?*anyopaque, preader.*.lines.items), preader.*.lines.capacity *% @sizeOf(ParserLine)))); + preader.*.lines.items = tmp_5; + break :blk_4 tmp_5; + }; + }; + break :blk_2 @as(c_int, 0); + } else @as(c_int, 0); + break :blk_1 preader.*.lines.items + (blk_2: { + const ref = &preader.*.lines.size; + const tmp_3 = ref.*; + ref.* +%= 1; + break :blk_2 tmp_3; + }); + }).* = tmp; + break :blk tmp; + }; + ret_pline.* = pline; +} +pub inline fn viml_parser_get_remaining_line(pstate: [*c]ParserState, ret_pline: [*c]ParserLine) bool { + const num_lines: usize = pstate.*.reader.lines.size; + if (pstate.*.pos.line == num_lines) { + viml_preader_get_line(&pstate.*.reader, ret_pline); + } else { + ret_pline.* = pstate.*.reader.lines.items[(pstate.*.reader.lines.size -% @bitCast(usize, @as(c_long, @as(c_int, 0)))) -% @bitCast(usize, @as(c_long, @as(c_int, 1)))]; + } + _ = blk: { + _ = @sizeOf(c_int); + break :blk blk_1: { + break :blk_1 if (pstate.*.pos.line == (pstate.*.reader.lines.size -% @bitCast(usize, @as(c_long, @as(c_int, 1))))) {} else { + __assert_fail("pstate->pos.line == kv_size(pstate->reader.lines) - 1", "_nvim/src/nvim/viml/parser/parser.h", @bitCast(c_uint, @as(c_int, 172)), "_Bool viml_parser_get_remaining_line(ParserState *const, ParserLine *const)"); + }; + }; + }; + if (ret_pline.*.data != @ptrCast([*c]const u8, @alignCast(@import("std").meta.alignment([*c]const u8), @intToPtr(?*anyopaque, @as(c_int, 0))))) { + ret_pline.*.data += pstate.*.pos.col; + ret_pline.*.size -%= pstate.*.pos.col; + } + return ret_pline.*.data != @ptrCast([*c]const u8, @alignCast(@import("std").meta.alignment([*c]const u8), @intToPtr(?*anyopaque, @as(c_int, 0)))); +} +pub inline fn viml_parser_advance(pstate: [*c]ParserState, len: usize) void { + _ = blk: { + _ = @sizeOf(c_int); + break :blk blk_1: { + break :blk_1 if (pstate.*.pos.line == (pstate.*.reader.lines.size -% @bitCast(usize, @as(c_long, @as(c_int, 1))))) {} else { + __assert_fail("pstate->pos.line == kv_size(pstate->reader.lines) - 1", "_nvim/src/nvim/viml/parser/parser.h", @bitCast(c_uint, @as(c_int, 191)), "void viml_parser_advance(ParserState *const, const size_t)"); + }; + }; + }; + const pline: ParserLine = pstate.*.reader.lines.items[(pstate.*.reader.lines.size -% @bitCast(usize, @as(c_long, @as(c_int, 0)))) -% @bitCast(usize, @as(c_long, @as(c_int, 1)))]; + if ((pstate.*.pos.col +% len) >= pline.size) { + pstate.*.pos.line +%= 1; + pstate.*.pos.col = 0; + } else { + pstate.*.pos.col +%= len; + } +} +pub inline fn viml_parser_highlight(pstate: [*c]ParserState, start: ParserPosition, len: usize, group: [*c]const u8) void { + if ((pstate.*.colors == @ptrCast([*c]ParserHighlight, @alignCast(@import("std").meta.alignment([*c]ParserHighlight), @intToPtr(?*anyopaque, @as(c_int, 0))))) or (len == @bitCast(usize, @as(c_long, @as(c_int, 0))))) { + return; + } + _ = blk: { + _ = @sizeOf(c_int); + break :blk blk_1: { + break :blk_1 if (((pstate.*.colors.*.size == @bitCast(usize, @as(c_long, @as(c_int, 0)))) or (pstate.*.colors.*.items[(pstate.*.colors.*.size -% @bitCast(usize, @as(c_long, @as(c_int, 0)))) -% @bitCast(usize, @as(c_long, @as(c_int, 1)))].start.line < start.line)) or (pstate.*.colors.*.items[(pstate.*.colors.*.size -% @bitCast(usize, @as(c_long, @as(c_int, 0)))) -% @bitCast(usize, @as(c_long, @as(c_int, 1)))].end_col <= start.col)) {} else { + __assert_fail("kv_size(*pstate->colors) == 0 || kv_Z(*pstate->colors, 0).start.line < start.line || kv_Z(*pstate->colors, 0).end_col <= start.col", "_nvim/src/nvim/viml/parser/parser.h", @bitCast(c_uint, @as(c_int, 219)), "void viml_parser_highlight(ParserState *const, const ParserPosition, const size_t, const char *const)"); + }; + }; + }; + _ = blk: { + const tmp = ParserHighlightChunk{ + .start = start, + .end_col = start.col +% len, + .group = group, + }; + (blk_1: { + _ = if (pstate.*.colors.*.size == pstate.*.colors.*.capacity) blk_2: { + _ = blk_3: { + pstate.*.colors.*.capacity = if ((pstate.*.colors.*.capacity << @intCast(@import("std").math.Log2Int(usize), 1)) > ((@sizeOf([16]ParserHighlightChunk) / @sizeOf(ParserHighlightChunk)) / @bitCast(usize, @as(c_long, @boolToInt(!((@sizeOf([16]ParserHighlightChunk) % @sizeOf(ParserHighlightChunk)) != 0)))))) pstate.*.colors.*.capacity << @intCast(@import("std").math.Log2Int(usize), 1) else (@sizeOf([16]ParserHighlightChunk) / @sizeOf(ParserHighlightChunk)) / @bitCast(usize, @as(c_long, @boolToInt(!((@sizeOf([16]ParserHighlightChunk) % @sizeOf(ParserHighlightChunk)) != 0)))); + break :blk_3 blk_4: { + const tmp_5 = @ptrCast([*c]ParserHighlightChunk, @alignCast(@import("std").meta.alignment([*c]ParserHighlightChunk), if (pstate.*.colors.*.capacity == ((@sizeOf([16]ParserHighlightChunk) / @sizeOf(ParserHighlightChunk)) / @bitCast(usize, @as(c_long, @boolToInt(!((@sizeOf([16]ParserHighlightChunk) % @sizeOf(ParserHighlightChunk)) != 0)))))) if (pstate.*.colors.*.items == @ptrCast([*c]ParserHighlightChunk, @alignCast(@import("std").meta.alignment([*c]ParserHighlightChunk), &pstate.*.colors.*.init_array))) @ptrCast(?*anyopaque, pstate.*.colors.*.items) else _memcpy_free(@ptrCast(?*anyopaque, @ptrCast([*c]ParserHighlightChunk, @alignCast(@import("std").meta.alignment([*c]ParserHighlightChunk), &pstate.*.colors.*.init_array))), @ptrCast(?*anyopaque, pstate.*.colors.*.items), pstate.*.colors.*.size *% @sizeOf(ParserHighlightChunk)) else if (pstate.*.colors.*.items == @ptrCast([*c]ParserHighlightChunk, @alignCast(@import("std").meta.alignment([*c]ParserHighlightChunk), &pstate.*.colors.*.init_array))) memcpy(xmalloc(pstate.*.colors.*.capacity *% @sizeOf(ParserHighlightChunk)), @ptrCast(?*const anyopaque, pstate.*.colors.*.items), pstate.*.colors.*.size *% @sizeOf(ParserHighlightChunk)) else xrealloc(@ptrCast(?*anyopaque, pstate.*.colors.*.items), pstate.*.colors.*.capacity *% @sizeOf(ParserHighlightChunk)))); + pstate.*.colors.*.items = tmp_5; + break :blk_4 tmp_5; + }; + }; + break :blk_2 @as(c_int, 0); + } else @as(c_int, 0); + break :blk_1 pstate.*.colors.*.items + (blk_2: { + const ref = &pstate.*.colors.*.size; + const tmp_3 = ref.*; + ref.* +%= 1; + break :blk_2 tmp_3; + }); + }).* = tmp; + break :blk tmp; + }; +} +pub extern fn parser_simple_get_line(cookie: ?*anyopaque, ret_pline: [*c]ParserLine) void; +pub const ExprASTNode = struct_expr_ast_node; +const struct_unnamed_164 = extern struct { + name: c_int, +}; +const struct_unnamed_166 = extern struct { + allow_dict: bool, + allow_lambda: bool, + allow_ident: bool, +}; +const struct_unnamed_165 = extern struct { + type_guesses: struct_unnamed_166, + opening_hl_idx: usize, +}; +const struct_unnamed_167 = extern struct { + scope: ExprVarScope, + ident: [*c]const u8, + ident_len: usize, +}; +const struct_unnamed_168 = extern struct { + got_colon: bool, +}; +const struct_unnamed_169 = extern struct { + type: ExprComparisonType, + ccs: ExprCaseCompareStrategy, + inv: bool, +}; +const struct_unnamed_170 = extern struct { + value: uvarnumber_T, +}; +const struct_unnamed_171 = extern struct { + value: float_T, +}; +const struct_unnamed_172 = extern struct { + value: [*c]u8, + size: usize, +}; +const struct_unnamed_173 = extern struct { + ident: [*c]const u8, + ident_len: usize, + scope: ExprOptScope, +}; +const struct_unnamed_174 = extern struct { + ident: [*c]const u8, + ident_len: usize, +}; +const struct_unnamed_175 = extern struct { + type: ExprAssignmentType, +}; +const union_unnamed_163 = extern union { + reg: struct_unnamed_164, + fig: struct_unnamed_165, + @"var": struct_unnamed_167, + ter: struct_unnamed_168, + cmp: struct_unnamed_169, + num: struct_unnamed_170, + flt: struct_unnamed_171, + str: struct_unnamed_172, + opt: struct_unnamed_173, + env: struct_unnamed_174, + ass: struct_unnamed_175, +}; +pub const struct_expr_ast_node = extern struct { + type: ExprASTNodeType, + children: [*c]ExprASTNode, + next: [*c]ExprASTNode, + start: ParserPosition, + len: usize, + data: union_unnamed_163, +}; +pub const kCCStrategyUseOption: c_int = 0; +pub const kCCStrategyMatchCase: c_int = 35; +pub const kCCStrategyIgnoreCase: c_int = 63; +pub const ExprCaseCompareStrategy = c_uint; +pub const kExprLexInvalid: c_int = 0; +pub const kExprLexMissing: c_int = 1; +pub const kExprLexSpacing: c_int = 2; +pub const kExprLexEOC: c_int = 3; +pub const kExprLexQuestion: c_int = 4; +pub const kExprLexColon: c_int = 5; +pub const kExprLexOr: c_int = 6; +pub const kExprLexAnd: c_int = 7; +pub const kExprLexComparison: c_int = 8; +pub const kExprLexPlus: c_int = 9; +pub const kExprLexMinus: c_int = 10; +pub const kExprLexDot: c_int = 11; +pub const kExprLexMultiplication: c_int = 12; +pub const kExprLexNot: c_int = 13; +pub const kExprLexNumber: c_int = 14; +pub const kExprLexSingleQuotedString: c_int = 15; +pub const kExprLexDoubleQuotedString: c_int = 16; +pub const kExprLexOption: c_int = 17; +pub const kExprLexRegister: c_int = 18; +pub const kExprLexEnv: c_int = 19; +pub const kExprLexPlainIdentifier: c_int = 20; +pub const kExprLexBracket: c_int = 21; +pub const kExprLexFigureBrace: c_int = 22; +pub const kExprLexParenthesis: c_int = 23; +pub const kExprLexComma: c_int = 24; +pub const kExprLexArrow: c_int = 25; +pub const kExprLexAssignment: c_int = 26; +pub const LexExprTokenType = c_uint; +pub const kExprCmpEqual: c_int = 0; +pub const kExprCmpMatches: c_int = 1; +pub const kExprCmpGreater: c_int = 2; +pub const kExprCmpGreaterOrEqual: c_int = 3; +pub const kExprCmpIdentical: c_int = 4; +pub const ExprComparisonType = c_uint; +pub const kExprOptScopeUnspecified: c_int = 0; +pub const kExprOptScopeGlobal: c_int = 103; +pub const kExprOptScopeLocal: c_int = 108; +pub const ExprOptScope = c_uint; +pub const kExprAsgnPlain: c_int = 0; +pub const kExprAsgnAdd: c_int = 1; +pub const kExprAsgnSubtract: c_int = 2; +pub const kExprAsgnConcat: c_int = 3; +pub const ExprAssignmentType = c_uint; +pub const kExprVarScopeMissing: c_int = 0; +pub const kExprVarScopeScript: c_int = 115; +pub const kExprVarScopeGlobal: c_int = 103; +pub const kExprVarScopeVim: c_int = 118; +pub const kExprVarScopeBuffer: c_int = 98; +pub const kExprVarScopeWindow: c_int = 119; +pub const kExprVarScopeTabpage: c_int = 116; +pub const kExprVarScopeLocal: c_int = 108; +pub const kExprVarScopeArguments: c_int = 97; +pub const ExprVarScope = c_uint; +const struct_unnamed_177 = extern struct { + type: ExprComparisonType, + ccs: ExprCaseCompareStrategy, + inv: bool, +}; +pub const kExprLexMulMul: c_int = 0; +pub const kExprLexMulDiv: c_int = 1; +pub const kExprLexMulMod: c_int = 2; +const enum_unnamed_179 = c_uint; +const struct_unnamed_178 = extern struct { + type: enum_unnamed_179, +}; +const struct_unnamed_180 = extern struct { + closing: bool, +}; +const struct_unnamed_181 = extern struct { + name: c_int, +}; +const struct_unnamed_182 = extern struct { + closed: bool, +}; +const struct_unnamed_183 = extern struct { + name: [*c]const u8, + len: usize, + scope: ExprOptScope, +}; +const struct_unnamed_184 = extern struct { + scope: ExprVarScope, + autoload: bool, +}; +const struct_unnamed_185 = extern struct { + type: LexExprTokenType, + msg: [*c]const u8, +}; +const union_unnamed_187 = extern union { + floating: float_T, + integer: uvarnumber_T, +}; +const struct_unnamed_186 = extern struct { + val: union_unnamed_187, + base: u8, + is_float: bool, +}; +const struct_unnamed_188 = extern struct { + type: ExprAssignmentType, +}; +const union_unnamed_176 = extern union { + cmp: struct_unnamed_177, + mul: struct_unnamed_178, + brc: struct_unnamed_180, + reg: struct_unnamed_181, + str: struct_unnamed_182, + opt: struct_unnamed_183, + @"var": struct_unnamed_184, + err: struct_unnamed_185, + num: struct_unnamed_186, + ass: struct_unnamed_188, +}; +pub const LexExprToken = extern struct { + start: ParserPosition, + len: usize, + type: LexExprTokenType, + data: union_unnamed_176, +}; +pub const kELFlagPeek: c_int = 1; +pub const kELFlagForbidScope: c_int = 2; +pub const kELFlagAllowFloat: c_int = 4; +pub const kELFlagIsNotCmp: c_int = 8; +pub const kELFlagForbidEOC: c_int = 16; +pub const LexExprFlags = c_uint; +pub const kExprNodeMissing: c_int = 0; +pub const kExprNodeOpMissing: c_int = 1; +pub const kExprNodeTernary: c_int = 2; +pub const kExprNodeTernaryValue: c_int = 3; +pub const kExprNodeRegister: c_int = 4; +pub const kExprNodeSubscript: c_int = 5; +pub const kExprNodeListLiteral: c_int = 6; +pub const kExprNodeUnaryPlus: c_int = 7; +pub const kExprNodeBinaryPlus: c_int = 8; +pub const kExprNodeNested: c_int = 9; +pub const kExprNodeCall: c_int = 10; +pub const kExprNodePlainIdentifier: c_int = 11; +pub const kExprNodePlainKey: c_int = 12; +pub const kExprNodeComplexIdentifier: c_int = 13; +pub const kExprNodeUnknownFigure: c_int = 14; +pub const kExprNodeLambda: c_int = 15; +pub const kExprNodeDictLiteral: c_int = 16; +pub const kExprNodeCurlyBracesIdentifier: c_int = 17; +pub const kExprNodeComma: c_int = 18; +pub const kExprNodeColon: c_int = 19; +pub const kExprNodeArrow: c_int = 20; +pub const kExprNodeComparison: c_int = 21; +pub const kExprNodeConcat: c_int = 22; +pub const kExprNodeConcatOrSubscript: c_int = 23; +pub const kExprNodeInteger: c_int = 24; +pub const kExprNodeFloat: c_int = 25; +pub const kExprNodeSingleQuotedString: c_int = 26; +pub const kExprNodeDoubleQuotedString: c_int = 27; +pub const kExprNodeOr: c_int = 28; +pub const kExprNodeAnd: c_int = 29; +pub const kExprNodeUnaryMinus: c_int = 30; +pub const kExprNodeBinaryMinus: c_int = 31; +pub const kExprNodeNot: c_int = 32; +pub const kExprNodeMultiplication: c_int = 33; +pub const kExprNodeDivision: c_int = 34; +pub const kExprNodeMod: c_int = 35; +pub const kExprNodeOption: c_int = 36; +pub const kExprNodeEnvironment: c_int = 37; +pub const kExprNodeAssignment: c_int = 38; +pub const ExprASTNodeType = c_uint; +pub const kExprFlagsMulti: c_int = 1; +pub const kExprFlagsDisallowEOC: c_int = 2; +pub const kExprFlagsParseLet: c_int = 4; +pub const enum_ExprParserFlags = c_uint; +pub const ExprASTError = extern struct { + msg: [*c]const u8, + arg: [*c]const u8, + arg_len: c_int, +}; +pub const ExprAST = extern struct { + err: ExprASTError, + root: [*c]ExprASTNode, +}; +pub const node_maxchildren: [*c]const u8 = @extern([*c]const u8, .{ + .name = "node_maxchildren", +}); +pub const east_node_type_tab: [*c]const [*c]const u8 = @extern([*c]const [*c]const u8, .{ + .name = "east_node_type_tab", +}); +pub const eltkn_cmp_type_tab: [*c]const [*c]const u8 = @extern([*c]const [*c]const u8, .{ + .name = "eltkn_cmp_type_tab", +}); +pub const ccs_tab: [*c]const [*c]const u8 = @extern([*c]const [*c]const u8, .{ + .name = "ccs_tab", +}); +pub const expr_asgn_type_tab: [*c]const [*c]const u8 = @extern([*c]const [*c]const u8, .{ + .name = "expr_asgn_type_tab", +}); +pub extern fn viml_pexpr_next_token(pstate: [*c]ParserState, flags: c_int) LexExprToken; +pub extern fn viml_pexpr_repr_token(pstate: [*c]const ParserState, token: LexExprToken, ret_size: [*c]usize) [*c]const u8; +pub extern fn viml_pexpr_free_ast(ast: ExprAST) void; +pub extern fn viml_pexpr_parse(pstate: [*c]ParserState, flags: c_int) ExprAST; +pub const __INTMAX_C_SUFFIX__ = @compileError("unable to translate macro: undefined identifier `L`"); // (no file):80:9 +pub const __UINTMAX_C_SUFFIX__ = @compileError("unable to translate macro: undefined identifier `UL`"); // (no file):86:9 +pub const __FLT16_DENORM_MIN__ = @compileError("unable to translate C expr: unexpected token 'IntegerLiteral'"); // (no file):109:9 +pub const __FLT16_EPSILON__ = @compileError("unable to translate C expr: unexpected token 'IntegerLiteral'"); // (no file):113:9 +pub const __FLT16_MAX__ = @compileError("unable to translate C expr: unexpected token 'IntegerLiteral'"); // (no file):119:9 +pub const __FLT16_MIN__ = @compileError("unable to translate C expr: unexpected token 'IntegerLiteral'"); // (no file):122:9 +pub const __INT64_C_SUFFIX__ = @compileError("unable to translate macro: undefined identifier `L`"); // (no file):183:9 +pub const __UINT32_C_SUFFIX__ = @compileError("unable to translate macro: undefined identifier `U`"); // (no file):205:9 +pub const __UINT64_C_SUFFIX__ = @compileError("unable to translate macro: undefined identifier `UL`"); // (no file):213:9 +pub const __seg_gs = @compileError("unable to translate macro: undefined identifier `__attribute__`"); // (no file):343:9 +pub const __seg_fs = @compileError("unable to translate macro: undefined identifier `__attribute__`"); // (no file):344:9 +pub const __GLIBC_USE = @compileError("unable to translate macro: undefined identifier `__GLIBC_USE_`"); // /usr/include/features.h:187:9 +pub const __glibc_has_attribute = @compileError("unable to translate macro: undefined identifier `__has_attribute`"); // /usr/include/sys/cdefs.h:45:10 +pub const __glibc_has_extension = @compileError("unable to translate macro: undefined identifier `__has_extension`"); // /usr/include/sys/cdefs.h:55:10 +pub const __THROW = @compileError("unable to translate macro: undefined identifier `__attribute__`"); // /usr/include/sys/cdefs.h:79:11 +pub const __THROWNL = @compileError("unable to translate macro: undefined identifier `__attribute__`"); // /usr/include/sys/cdefs.h:80:11 +pub const __NTH = @compileError("unable to translate macro: undefined identifier `__attribute__`"); // /usr/include/sys/cdefs.h:81:11 +pub const __NTHNL = @compileError("unable to translate macro: undefined identifier `__attribute__`"); // /usr/include/sys/cdefs.h:82:11 +pub const __CONCAT = @compileError("unable to translate C expr: unexpected token '##'"); // /usr/include/sys/cdefs.h:124:9 +pub const __STRING = @compileError("unable to translate C expr: unexpected token '#'"); // /usr/include/sys/cdefs.h:125:9 +pub const __glibc_unsigned_or_positive = @compileError("unable to translate macro: undefined identifier `__typeof`"); // /usr/include/sys/cdefs.h:160:9 +pub const __glibc_fortify = @compileError("unable to translate C expr: expected ')' instead got '...'"); // /usr/include/sys/cdefs.h:185:9 +pub const __glibc_fortify_n = @compileError("unable to translate C expr: expected ')' instead got '...'"); // /usr/include/sys/cdefs.h:195:9 +pub const __warnattr = @compileError("unable to translate C expr: unexpected token 'Eof'"); // /usr/include/sys/cdefs.h:207:10 +pub const __errordecl = @compileError("unable to translate C expr: unexpected token 'extern'"); // /usr/include/sys/cdefs.h:208:10 +pub const __flexarr = @compileError("unable to translate C expr: unexpected token '['"); // /usr/include/sys/cdefs.h:216:10 +pub const __REDIRECT = @compileError("unable to translate macro: undefined identifier `__asm__`"); // /usr/include/sys/cdefs.h:247:10 +pub const __REDIRECT_NTH = @compileError("unable to translate macro: undefined identifier `__asm__`"); // /usr/include/sys/cdefs.h:254:11 +pub const __REDIRECT_NTHNL = @compileError("unable to translate macro: undefined identifier `__asm__`"); // /usr/include/sys/cdefs.h:256:11 +pub const __ASMNAME2 = @compileError("unable to translate C expr: unexpected token 'Identifier'"); // /usr/include/sys/cdefs.h:260:10 +pub const __attribute_malloc__ = @compileError("unable to translate macro: undefined identifier `__attribute__`"); // /usr/include/sys/cdefs.h:281:10 +pub const __attribute_alloc_size__ = @compileError("unable to translate C expr: unexpected token 'Eof'"); // /usr/include/sys/cdefs.h:292:10 +pub const __attribute_alloc_align__ = @compileError("unable to translate macro: undefined identifier `__attribute__`"); // /usr/include/sys/cdefs.h:298:10 +pub const __attribute_pure__ = @compileError("unable to translate macro: undefined identifier `__attribute__`"); // /usr/include/sys/cdefs.h:308:10 +pub const __attribute_const__ = @compileError("unable to translate macro: undefined identifier `__attribute__`"); // /usr/include/sys/cdefs.h:315:10 +pub const __attribute_maybe_unused__ = @compileError("unable to translate macro: undefined identifier `__attribute__`"); // /usr/include/sys/cdefs.h:321:10 +pub const __attribute_used__ = @compileError("unable to translate macro: undefined identifier `__attribute__`"); // /usr/include/sys/cdefs.h:330:10 +pub const __attribute_noinline__ = @compileError("unable to translate macro: undefined identifier `__attribute__`"); // /usr/include/sys/cdefs.h:331:10 +pub const __attribute_deprecated__ = @compileError("unable to translate macro: undefined identifier `__attribute__`"); // /usr/include/sys/cdefs.h:339:10 +pub const __attribute_deprecated_msg__ = @compileError("unable to translate macro: undefined identifier `__attribute__`"); // /usr/include/sys/cdefs.h:349:10 +pub const __attribute_format_arg__ = @compileError("unable to translate macro: undefined identifier `__attribute__`"); // /usr/include/sys/cdefs.h:362:10 +pub const __attribute_format_strfmon__ = @compileError("unable to translate macro: undefined identifier `__attribute__`"); // /usr/include/sys/cdefs.h:372:10 +pub const __attribute_nonnull__ = @compileError("unable to translate macro: undefined identifier `__attribute__`"); // /usr/include/sys/cdefs.h:384:11 +pub const __returns_nonnull = @compileError("unable to translate macro: undefined identifier `__attribute__`"); // /usr/include/sys/cdefs.h:397:10 +pub const __attribute_warn_unused_result__ = @compileError("unable to translate macro: undefined identifier `__attribute__`"); // /usr/include/sys/cdefs.h:406:10 +pub const __always_inline = @compileError("unable to translate macro: undefined identifier `__inline`"); // /usr/include/sys/cdefs.h:424:10 +pub const __attribute_artificial__ = @compileError("unable to translate macro: undefined identifier `__attribute__`"); // /usr/include/sys/cdefs.h:433:10 +pub const __extern_inline = @compileError("unable to translate macro: undefined identifier `__inline`"); // /usr/include/sys/cdefs.h:451:11 +pub const __extern_always_inline = @compileError("unable to translate macro: undefined identifier `__attribute__`"); // /usr/include/sys/cdefs.h:452:11 +pub const __restrict_arr = @compileError("unable to translate macro: undefined identifier `__restrict`"); // /usr/include/sys/cdefs.h:495:10 +pub const __attribute_copy__ = @compileError("unable to translate C expr: unexpected token 'Eof'"); // /usr/include/sys/cdefs.h:544:10 +pub const __LDBL_REDIR2_DECL = @compileError("unable to translate C expr: unexpected token 'Eof'"); // /usr/include/sys/cdefs.h:620:10 +pub const __LDBL_REDIR_DECL = @compileError("unable to translate C expr: unexpected token 'Eof'"); // /usr/include/sys/cdefs.h:621:10 +pub const __glibc_macro_warning1 = @compileError("unable to translate macro: undefined identifier `_Pragma`"); // /usr/include/sys/cdefs.h:635:10 +pub const __glibc_macro_warning = @compileError("unable to translate macro: undefined identifier `GCC`"); // /usr/include/sys/cdefs.h:636:10 +pub const __fortified_attr_access = @compileError("unable to translate C expr: unexpected token 'Eof'"); // /usr/include/sys/cdefs.h:681:11 +pub const __attr_access = @compileError("unable to translate C expr: unexpected token 'Eof'"); // /usr/include/sys/cdefs.h:682:11 +pub const __attr_access_none = @compileError("unable to translate C expr: unexpected token 'Eof'"); // /usr/include/sys/cdefs.h:683:11 +pub const __attr_dealloc = @compileError("unable to translate C expr: unexpected token 'Eof'"); // /usr/include/sys/cdefs.h:693:10 +pub const __attribute_returns_twice__ = @compileError("unable to translate macro: undefined identifier `__attribute__`"); // /usr/include/sys/cdefs.h:700:10 +pub const __STD_TYPE = @compileError("unable to translate C expr: unexpected token 'typedef'"); // /usr/include/bits/types.h:137:10 +pub const __FSID_T_TYPE = @compileError("unable to translate macro: undefined identifier `__val`"); // /usr/include/bits/typesizes.h:73:9 +pub const __CFLOAT32 = @compileError("unable to translate: TODO _Complex"); // /usr/include/bits/floatn-common.h:149:12 +pub const __CFLOAT64 = @compileError("unable to translate: TODO _Complex"); // /usr/include/bits/floatn-common.h:160:13 +pub const __CFLOAT32X = @compileError("unable to translate: TODO _Complex"); // /usr/include/bits/floatn-common.h:169:12 +pub const __CFLOAT64X = @compileError("unable to translate: TODO _Complex"); // /usr/include/bits/floatn-common.h:178:13 +pub const __builtin_nansf32 = @compileError("unable to translate macro: undefined identifier `__builtin_nansf`"); // /usr/include/bits/floatn-common.h:221:12 +pub const __builtin_huge_valf64 = @compileError("unable to translate macro: undefined identifier `__builtin_huge_val`"); // /usr/include/bits/floatn-common.h:255:13 +pub const __builtin_inff64 = @compileError("unable to translate macro: undefined identifier `__builtin_inf`"); // /usr/include/bits/floatn-common.h:256:13 +pub const __builtin_nanf64 = @compileError("unable to translate macro: undefined identifier `__builtin_nan`"); // /usr/include/bits/floatn-common.h:257:13 +pub const __builtin_nansf64 = @compileError("unable to translate macro: undefined identifier `__builtin_nans`"); // /usr/include/bits/floatn-common.h:258:13 +pub const __builtin_huge_valf32x = @compileError("unable to translate macro: undefined identifier `__builtin_huge_val`"); // /usr/include/bits/floatn-common.h:272:12 +pub const __builtin_inff32x = @compileError("unable to translate macro: undefined identifier `__builtin_inf`"); // /usr/include/bits/floatn-common.h:273:12 +pub const __builtin_nanf32x = @compileError("unable to translate macro: undefined identifier `__builtin_nan`"); // /usr/include/bits/floatn-common.h:274:12 +pub const __builtin_nansf32x = @compileError("unable to translate macro: undefined identifier `__builtin_nans`"); // /usr/include/bits/floatn-common.h:275:12 +pub const __builtin_huge_valf64x = @compileError("unable to translate macro: undefined identifier `__builtin_huge_vall`"); // /usr/include/bits/floatn-common.h:289:13 +pub const __builtin_inff64x = @compileError("unable to translate macro: undefined identifier `__builtin_infl`"); // /usr/include/bits/floatn-common.h:290:13 +pub const __builtin_nanf64x = @compileError("unable to translate macro: undefined identifier `__builtin_nanl`"); // /usr/include/bits/floatn-common.h:291:13 +pub const __builtin_nansf64x = @compileError("unable to translate macro: undefined identifier `__builtin_nansl`"); // /usr/include/bits/floatn-common.h:292:13 +pub const __FD_ZERO = @compileError("unable to translate macro: undefined identifier `__i`"); // /usr/include/bits/select.h:25:9 +pub const __FD_SET = @compileError("unable to translate C expr: expected ')' instead got '|='"); // /usr/include/bits/select.h:32:9 +pub const __FD_CLR = @compileError("unable to translate C expr: expected ')' instead got '&='"); // /usr/include/bits/select.h:34:9 +pub const __PTHREAD_MUTEX_INITIALIZER = @compileError("unable to translate C expr: unexpected token '{'"); // /usr/include/bits/struct_mutex.h:56:10 +pub const __PTHREAD_RWLOCK_ELISION_EXTRA = @compileError("unable to translate C expr: unexpected token '{'"); // /usr/include/bits/struct_rwlock.h:40:11 +pub const __ONCE_FLAG_INIT = @compileError("unable to translate C expr: unexpected token '{'"); // /usr/include/bits/thread-shared-types.h:113:9 +pub const offsetof = @compileError("unable to translate macro: undefined identifier `__builtin_offsetof`"); // /home/lordmzte/.local/share/zupper/installs/master/lib/include/stddef.h:111:9 +pub const ENDIAN_INCLUDE_FILE = @compileError("unable to translate macro: undefined identifier `endian`"); // _nvim/build/cmake.config/auto/config.h:54:9 +pub const EXTERN = @compileError("unable to translate C expr: unexpected token 'extern'"); // ./_nvim/src/nvim/macros.h:9:10 +pub const INIT = @compileError("unable to translate C expr: expected ')' instead got '...'"); // ./_nvim/src/nvim/macros.h:10:10 +pub const LANGMAP_ADJUST = @compileError("unable to translate C expr: unexpected token 'do'"); // ./_nvim/src/nvim/macros.h:66:9 +pub const MB_PTR_ADV = @compileError("unable to translate C expr: expected ')' instead got '+='"); // ./_nvim/src/nvim/macros.h:98:9 +pub const MB_CPTR_ADV = @compileError("unable to translate C expr: expected ')' instead got '+='"); // ./_nvim/src/nvim/macros.h:101:9 +pub const MB_PTR_BACK = @compileError("unable to translate C expr: expected ')' instead got '-='"); // ./_nvim/src/nvim/macros.h:105:9 +pub const MB_CHAR2BYTES = @compileError("unable to translate C expr: expected ')' instead got '+='"); // ./_nvim/src/nvim/macros.h:109:9 +pub const RESET_BINDING = @compileError("unable to translate C expr: unexpected token 'do'"); // ./_nvim/src/nvim/macros.h:111:9 +pub const ARRAY_SIZE = @compileError("unable to translate C expr: unexpected token '('"); // ./_nvim/src/nvim/macros.h:125:9 +pub const STR_ = @compileError("unable to translate C expr: unexpected token '#'"); // ./_nvim/src/nvim/macros.h:138:9 +pub const NVIM_HAS_INCLUDE = @compileError("unable to translate macro: undefined identifier `__has_include`"); // ./_nvim/src/nvim/macros.h:144:10 +pub const NVIM_HAS_ATTRIBUTE = @compileError("unable to translate macro: undefined identifier `__has_attribute`"); // ./_nvim/src/nvim/macros.h:156:10 +pub const FALLTHROUGH = @compileError("unable to translate macro: undefined identifier `__attribute__`"); // ./_nvim/src/nvim/macros.h:161:10 +pub const STRUCT_CAST = @compileError("unable to translate C expr: unexpected token ')'"); // ./_nvim/src/nvim/macros.h:176:9 +pub const PRAGMA_DIAG_PUSH_IGNORE_MISSING_PROTOTYPES = @compileError("unable to translate macro: undefined identifier `_Pragma`"); // ./_nvim/src/nvim/macros.h:197:10 +pub const PRAGMA_DIAG_PUSH_IGNORE_IMPLICIT_FALLTHROUGH = @compileError("unable to translate macro: undefined identifier `_Pragma`"); // ./_nvim/src/nvim/macros.h:201:11 +pub const PRAGMA_DIAG_POP = @compileError("unable to translate macro: undefined identifier `_Pragma`"); // ./_nvim/src/nvim/macros.h:208:10 +pub const ARENA_EMPTY = @compileError("unable to translate C expr: unexpected token '{'"); // ./_nvim/src/nvim/memory.h:56:9 +pub const kv_fixsize_arena = @compileError("unable to translate C expr: expected ')' instead got '='"); // ./_nvim/src/nvim/memory.h:58:9 +pub const REAL_FATTR_MALLOC = @compileError("unable to translate macro: undefined identifier `__attribute__`"); // ./_nvim/src/nvim/func_attr.h:118:11 +pub const REAL_FATTR_ALLOC_ALIGN = @compileError("unable to translate macro: undefined identifier `__attribute__`"); // ./_nvim/src/nvim/func_attr.h:119:11 +pub const REAL_FATTR_PURE = @compileError("unable to translate macro: undefined identifier `__attribute__`"); // ./_nvim/src/nvim/func_attr.h:120:11 +pub const REAL_FATTR_CONST = @compileError("unable to translate macro: undefined identifier `__attribute__`"); // ./_nvim/src/nvim/func_attr.h:121:11 +pub const REAL_FATTR_WARN_UNUSED_RESULT = @compileError("unable to translate macro: undefined identifier `__attribute__`"); // ./_nvim/src/nvim/func_attr.h:122:11 +pub const REAL_FATTR_ALWAYS_INLINE = @compileError("unable to translate macro: undefined identifier `__attribute__`"); // ./_nvim/src/nvim/func_attr.h:123:11 +pub const REAL_FATTR_UNUSED = @compileError("unable to translate macro: undefined identifier `__attribute__`"); // ./_nvim/src/nvim/func_attr.h:124:11 +pub const REAL_FATTR_NONNULL_ALL = @compileError("unable to translate macro: undefined identifier `__attribute__`"); // ./_nvim/src/nvim/func_attr.h:125:11 +pub const REAL_FATTR_NONNULL_ARG = @compileError("unable to translate C expr: expected ')' instead got '...'"); // ./_nvim/src/nvim/func_attr.h:126:11 +pub const REAL_FATTR_NORETURN = @compileError("unable to translate macro: undefined identifier `__attribute__`"); // ./_nvim/src/nvim/func_attr.h:127:11 +pub const REAL_FATTR_PRINTF = @compileError("unable to translate macro: undefined identifier `__attribute__`"); // ./_nvim/src/nvim/func_attr.h:128:11 +pub const REAL_FATTR_NONNULL_RET = @compileError("unable to translate macro: undefined identifier `__attribute__`"); // ./_nvim/src/nvim/func_attr.h:131:12 +pub const REAL_FATTR_ALLOC_SIZE = @compileError("unable to translate macro: undefined identifier `__attribute__`"); // ./_nvim/src/nvim/func_attr.h:135:12 +pub const REAL_FATTR_ALLOC_SIZE_PROD = @compileError("unable to translate macro: undefined identifier `__attribute__`"); // ./_nvim/src/nvim/func_attr.h:136:12 +pub const REAL_FATTR_NO_SANITIZE_UNDEFINED = @compileError("unable to translate macro: undefined identifier `__attribute__`"); // ./_nvim/src/nvim/func_attr.h:143:12 +pub const REAL_FATTR_NO_SANITIZE_ADDRESS = @compileError("unable to translate macro: undefined identifier `__attribute__`"); // ./_nvim/src/nvim/func_attr.h:148:12 +pub const FUNC_API_SINCE = @compileError("unable to translate C expr: unexpected token 'Eof'"); // ./_nvim/src/nvim/func_attr.h:232:10 +pub const FUNC_API_DEPRECATED_SINCE = @compileError("unable to translate C expr: unexpected token 'Eof'"); // ./_nvim/src/nvim/func_attr.h:234:10 +pub const FUNC_ATTR_NONNULL_ARG = @compileError("unable to translate C expr: expected ')' instead got '...'"); // ./_nvim/src/nvim/func_attr.h:245:10 +pub const XFREE_CLEAR = @compileError("unable to translate macro: undefined identifier `ptr_`"); // ./_nvim/src/nvim/memory.h:66:9 +pub const __exctype = @compileError("unable to translate C expr: unexpected token 'extern'"); // /usr/include/ctype.h:102:9 +pub const __tobody = @compileError("unable to translate macro: undefined identifier `__extension__`"); // /usr/include/ctype.h:155:9 +pub const __exctype_l = @compileError("unable to translate C expr: unexpected token 'extern'"); // /usr/include/ctype.h:244:10 +pub const __getc_unlocked_body = @compileError("TODO postfix inc/dec expr"); // /usr/include/bits/types/struct_FILE.h:102:9 +pub const __putc_unlocked_body = @compileError("TODO postfix inc/dec expr"); // /usr/include/bits/types/struct_FILE.h:106:9 +pub const st_atime = @compileError("unable to translate macro: undefined identifier `st_atim`"); // /usr/include/bits/struct_stat.h:77:11 +pub const st_mtime = @compileError("unable to translate macro: undefined identifier `st_mtim`"); // /usr/include/bits/struct_stat.h:78:11 +pub const st_ctime = @compileError("unable to translate macro: undefined identifier `st_ctim`"); // /usr/include/bits/struct_stat.h:79:11 +pub const si_pid = @compileError("unable to translate macro: undefined identifier `_sifields`"); // /usr/include/bits/types/siginfo_t.h:128:9 +pub const si_uid = @compileError("unable to translate macro: undefined identifier `_sifields`"); // /usr/include/bits/types/siginfo_t.h:129:9 +pub const si_timerid = @compileError("unable to translate macro: undefined identifier `_sifields`"); // /usr/include/bits/types/siginfo_t.h:130:9 +pub const si_overrun = @compileError("unable to translate macro: undefined identifier `_sifields`"); // /usr/include/bits/types/siginfo_t.h:131:9 +pub const si_status = @compileError("unable to translate macro: undefined identifier `_sifields`"); // /usr/include/bits/types/siginfo_t.h:132:9 +pub const si_utime = @compileError("unable to translate macro: undefined identifier `_sifields`"); // /usr/include/bits/types/siginfo_t.h:133:9 +pub const si_stime = @compileError("unable to translate macro: undefined identifier `_sifields`"); // /usr/include/bits/types/siginfo_t.h:134:9 +pub const si_value = @compileError("unable to translate macro: undefined identifier `_sifields`"); // /usr/include/bits/types/siginfo_t.h:135:9 +pub const si_int = @compileError("unable to translate macro: undefined identifier `_sifields`"); // /usr/include/bits/types/siginfo_t.h:136:9 +pub const si_ptr = @compileError("unable to translate macro: undefined identifier `_sifields`"); // /usr/include/bits/types/siginfo_t.h:137:9 +pub const si_addr = @compileError("unable to translate macro: undefined identifier `_sifields`"); // /usr/include/bits/types/siginfo_t.h:138:9 +pub const si_addr_lsb = @compileError("unable to translate macro: undefined identifier `_sifields`"); // /usr/include/bits/types/siginfo_t.h:139:9 +pub const si_lower = @compileError("unable to translate macro: undefined identifier `_sifields`"); // /usr/include/bits/types/siginfo_t.h:140:9 +pub const si_upper = @compileError("unable to translate macro: undefined identifier `_sifields`"); // /usr/include/bits/types/siginfo_t.h:141:9 +pub const si_pkey = @compileError("unable to translate macro: undefined identifier `_sifields`"); // /usr/include/bits/types/siginfo_t.h:142:9 +pub const si_band = @compileError("unable to translate macro: undefined identifier `_sifields`"); // /usr/include/bits/types/siginfo_t.h:143:9 +pub const si_fd = @compileError("unable to translate macro: undefined identifier `_sifields`"); // /usr/include/bits/types/siginfo_t.h:144:9 +pub const si_call_addr = @compileError("unable to translate macro: undefined identifier `_sifields`"); // /usr/include/bits/types/siginfo_t.h:146:10 +pub const si_syscall = @compileError("unable to translate macro: undefined identifier `_sifields`"); // /usr/include/bits/types/siginfo_t.h:147:10 +pub const si_arch = @compileError("unable to translate macro: undefined identifier `_sifields`"); // /usr/include/bits/types/siginfo_t.h:148:10 +pub const sigev_notify_function = @compileError("unable to translate macro: undefined identifier `_sigev_un`"); // /usr/include/bits/types/sigevent_t.h:45:9 +pub const sigev_notify_attributes = @compileError("unable to translate macro: undefined identifier `_sigev_un`"); // /usr/include/bits/types/sigevent_t.h:46:9 +pub const sa_handler = @compileError("unable to translate macro: undefined identifier `__sigaction_handler`"); // /usr/include/bits/sigaction.h:39:10 +pub const sa_sigaction = @compileError("unable to translate macro: undefined identifier `__sigaction_handler`"); // /usr/include/bits/sigaction.h:40:10 +pub const setbit = @compileError("unable to translate C expr: expected ')' instead got '|='"); // /usr/include/sys/param.h:83:9 +pub const clrbit = @compileError("unable to translate C expr: expected ')' instead got '&='"); // /usr/include/sys/param.h:84:9 +pub const TEMP_DIR_NAMES = @compileError("unable to translate C expr: unexpected token '{'"); // _nvim/src/nvim/os/unix_defs.h:13:9 +pub const HAVE_ACL = @compileError("unable to translate macro: undefined identifier `HAVE_POSIX_ACL`"); // _nvim/src/nvim/os/unix_defs.h:16:9 +pub const kv_roundup32 = @compileError("TODO unary inc/dec expr"); // _nvim/src/klib/kvec.h:46:9 +pub const KV_INITIAL_VALUE = @compileError("unable to translate C expr: unexpected token '{'"); // _nvim/src/klib/kvec.h:51:9 +pub const kvec_t = @compileError("unable to translate macro: undefined identifier `size`"); // _nvim/src/klib/kvec.h:53:9 +pub const kv_init = @compileError("unable to translate C expr: expected ')' instead got '='"); // _nvim/src/klib/kvec.h:60:9 +pub const kv_destroy = @compileError("unable to translate C expr: unexpected token 'do'"); // _nvim/src/klib/kvec.h:61:9 +pub const kv_pop = @compileError("TODO unary inc/dec expr"); // _nvim/src/klib/kvec.h:67:9 +pub const kv_drop = @compileError("unable to translate C expr: expected ')' instead got '-='"); // _nvim/src/klib/kvec.h:79:9 +pub const kv_resize = @compileError("unable to translate C expr: expected ')' instead got '='"); // _nvim/src/klib/kvec.h:81:9 +pub const kv_copy = @compileError("unable to translate C expr: unexpected token 'do'"); // _nvim/src/klib/kvec.h:88:9 +pub const kv_ensure_space = @compileError("unable to translate C expr: unexpected token 'do'"); // _nvim/src/klib/kvec.h:98:9 +pub const kv_concat_len = @compileError("unable to translate C expr: unexpected token 'do'"); // _nvim/src/klib/kvec.h:107:9 +pub const kv_pushp = @compileError("TODO postfix inc/dec expr"); // _nvim/src/klib/kvec.h:117:9 +pub const kv_push = @compileError("unable to translate C expr: expected ')' instead got '='"); // _nvim/src/klib/kvec.h:121:9 +pub const kv_pushp_c = @compileError("TODO postfix inc/dec expr"); // _nvim/src/klib/kvec.h:124:9 +pub const kv_push_c = @compileError("unable to translate C expr: expected ')' instead got '='"); // _nvim/src/klib/kvec.h:125:9 +pub const kv_a = @compileError("unable to translate C expr: expected ')' instead got '='"); // _nvim/src/klib/kvec.h:127:9 +pub const kv_printf = @compileError("unable to translate C expr: expected ')' instead got '...'"); // _nvim/src/klib/kvec.h:137:9 +pub const kvec_withinit_t = @compileError("unable to translate macro: undefined identifier `size`"); // _nvim/src/klib/kvec.h:147:9 +pub const kvi_init = @compileError("unable to translate C expr: expected ')' instead got '='"); // _nvim/src/klib/kvec.h:158:9 +pub const kvi_resize = @compileError("unable to translate C expr: expected ')' instead got '='"); // _nvim/src/klib/kvec.h:182:9 +pub const kvi_pushp = @compileError("TODO postfix inc/dec expr"); // _nvim/src/klib/kvec.h:215:9 +pub const kvi_push = @compileError("unable to translate C expr: expected ')' instead got '='"); // _nvim/src/klib/kvec.h:223:9 +pub const kvi_destroy = @compileError("unable to translate C expr: unexpected token 'do'"); // _nvim/src/klib/kvec.h:229:9 +pub const TRISTATE_TO_BOOL = @compileError("unable to translate C expr: expected ')' instead got 'default'"); // ./_nvim/src/nvim/types.h:44:9 +pub const STRING_INIT = @compileError("unable to translate C expr: unexpected token '{'"); // _nvim/src/nvim/api/private/defs.h:13:9 +pub const OBJECT_INIT = @compileError("unable to translate C expr: unexpected token '{'"); // _nvim/src/nvim/api/private/defs.h:14:9 +pub const REMOTE_TYPE = @compileError("unable to translate C expr: unexpected token 'typedef'"); // _nvim/src/nvim/api/private/defs.h:16:9 +pub const ArrayOf = @compileError("unable to translate C expr: expected ')' instead got '...'"); // _nvim/src/nvim/api/private/defs.h:21:10 +pub const DictionaryOf = @compileError("unable to translate C expr: expected ')' instead got '...'"); // _nvim/src/nvim/api/private/defs.h:22:10 +pub const Dict = @compileError("unable to translate macro: undefined identifier `KeyDict_`"); // _nvim/src/nvim/api/private/defs.h:23:10 +pub const LUA_API = @compileError("unable to translate C expr: unexpected token 'extern'"); // /usr/include/luaconf.h:282:9 +pub const LUAI_FUNC = @compileError("unable to translate macro: undefined identifier `__attribute__`"); // /usr/include/luaconf.h:310:9 +pub const l_floor = @compileError("unable to translate macro: undefined identifier `floor`"); // /usr/include/luaconf.h:403:9 +pub const lua_numbertointeger = @compileError("unable to translate C expr: expected ')' instead got '='"); // /usr/include/luaconf.h:417:9 +pub const l_floatatt = @compileError("unable to translate macro: undefined identifier `DBL_`"); // /usr/include/luaconf.h:460:9 +pub const lua_getlocaledecpoint = @compileError("unable to translate macro: undefined identifier `localeconv`"); // /usr/include/luaconf.h:656:9 +pub const LUAI_MAXALIGN = @compileError("unable to translate macro: undefined identifier `n`"); // /usr/include/luaconf.h:766:9 +pub const va_start = @compileError("unable to translate macro: undefined identifier `__builtin_va_start`"); // /home/lordmzte/.local/share/zupper/installs/master/lib/include/stdarg.h:33:9 +pub const va_end = @compileError("unable to translate macro: undefined identifier `__builtin_va_end`"); // /home/lordmzte/.local/share/zupper/installs/master/lib/include/stdarg.h:35:9 +pub const va_arg = @compileError("unable to translate macro: undefined identifier `__builtin_va_arg`"); // /home/lordmzte/.local/share/zupper/installs/master/lib/include/stdarg.h:36:9 +pub const __va_copy = @compileError("unable to translate macro: undefined identifier `__builtin_va_copy`"); // /home/lordmzte/.local/share/zupper/installs/master/lib/include/stdarg.h:41:9 +pub const va_copy = @compileError("unable to translate macro: undefined identifier `__builtin_va_copy`"); // /home/lordmzte/.local/share/zupper/installs/master/lib/include/stdarg.h:46:9 +pub const luaL_newlibtable = @compileError("unable to translate C expr: unexpected token '('"); // /usr/include/lauxlib.h:127:9 +pub const luaL_addchar = @compileError("TODO postfix inc/dec expr"); // /usr/include/lauxlib.h:207:9 +pub const luaL_addsize = @compileError("unable to translate C expr: expected ')' instead got '+='"); // /usr/include/lauxlib.h:211:9 +pub const luaL_buffsub = @compileError("unable to translate C expr: expected ')' instead got '-='"); // /usr/include/lauxlib.h:213:9 +pub const __ASSERT_VOID_CAST = @compileError("unable to translate C expr: unexpected token 'Eof'"); // /usr/include/assert.h:40:10 +pub const assert = @compileError("unable to translate macro: undefined identifier `__extension__`"); // /usr/include/assert.h:104:11 +pub const __ASSERT_FUNCTION = @compileError("unable to translate macro: undefined identifier `__extension__`"); // /usr/include/assert.h:126:12 +pub const static_assert = @compileError("unable to translate C expr: unexpected token '_Static_assert'"); // /usr/include/assert.h:144:10 +pub const _SDT_PROBE = @compileError("unable to translate macro: undefined identifier `__asm__`"); // /usr/include/sys/sdt.h:67:10 +pub const _SDT_S = @compileError("unable to translate C expr: unexpected token '#'"); // /usr/include/sys/sdt.h:73:10 +pub const _SDT_ASM_1 = @compileError("unable to translate C expr: unexpected token 'StringLiteral'"); // /usr/include/sys/sdt.h:74:10 +pub const _SDT_ASM_2 = @compileError("unable to translate C expr: unexpected token 'StringLiteral'"); // /usr/include/sys/sdt.h:75:10 +pub const _SDT_ASM_3 = @compileError("unable to translate C expr: unexpected token 'StringLiteral'"); // /usr/include/sys/sdt.h:76:10 +pub const _SDT_ASM_5 = @compileError("unable to translate C expr: unexpected token 'StringLiteral'"); // /usr/include/sys/sdt.h:78:10 +pub const _SDT_ASM_ARGS = @compileError("unable to translate macro: undefined identifier `_SDT_ASM_TEMPLATE_`"); // /usr/include/sys/sdt.h:81:10 +pub const _SDT_ASM_STRING_1 = @compileError("unable to translate C expr: unexpected token '.'"); // /usr/include/sys/sdt.h:82:10 +pub const _SDT_ARGFMT = @compileError("unable to translate macro: undefined identifier `n`"); // /usr/include/sys/sdt.h:84:10 +pub const STAP_SDT_ARG_CONSTRAINT = @compileError("unable to translate macro: undefined identifier `nor`"); // /usr/include/sys/sdt.h:90:10 +pub const _SDT_STRINGIFY = @compileError("unable to translate C expr: unexpected token '#'"); // /usr/include/sys/sdt.h:94:10 +pub const _SDT_ARG = @compileError("unable to translate macro: undefined identifier `_SDT_A`"); // /usr/include/sys/sdt.h:96:10 +pub const _SDT_ARGARRAY = @compileError("unable to translate macro: undefined identifier `__builtin_classify_type`"); // /usr/include/sys/sdt.h:102:9 +pub const _SDT_ARGINTTYPE = @compileError("unable to translate macro: undefined identifier `__typeof`"); // /usr/include/sys/sdt.h:165:10 +pub const _SDT_ARGSIGNED = @compileError("unable to translate macro: undefined identifier `__extension__`"); // /usr/include/sys/sdt.h:168:10 +pub const _SDT_ARGTMPL = @compileError("unable to translate C expr: unexpected token '%'"); // /usr/include/sys/sdt.h:185:10 +pub const _SDT_ASM_ADDR = @compileError("unable to translate macro: undefined identifier `byte`"); // /usr/include/sys/sdt.h:189:10 +pub const _SDT_NOP = @compileError("unable to translate macro: undefined identifier `nop`"); // /usr/include/sys/sdt.h:198:9 +pub const _SDT_ASM_BODY = @compileError("unable to translate macro: undefined identifier `byte`"); // /usr/include/sys/sdt.h:215:9 +pub const _SDT_ASM_BASE = @compileError("unable to translate macro: undefined identifier `comdat`"); // /usr/include/sys/sdt.h:231:9 +pub const _SDT_SEMAPHORE = @compileError("unable to translate C expr: expected ',' or ')' instead got 'IntegerLiteral'"); // /usr/include/sys/sdt.h:245:9 +pub const _SDT_ASM_OPERANDS_0 = @compileError("unable to translate macro: undefined identifier `__sdt_dummy`"); // /usr/include/sys/sdt.h:261:9 +pub const STAP_PROBE = @compileError("unable to translate C expr: unexpected token ')'"); // /usr/include/sys/sdt.h:294:9 +pub const STAP_PROBE_ASM = @compileError("unable to translate C expr: expected ')' instead got '...'"); // /usr/include/sys/sdt.h:389:10 +pub const STAP_PROBE_ASM_OPERANDS = @compileError("unable to translate C expr: expected ')' instead got '...'"); // /usr/include/sys/sdt.h:392:10 +pub const STAP_PROBE_ASM_TEMPLATE = @compileError("unable to translate macro: undefined identifier `_SDT_ASM_TEMPLATE_`"); // /usr/include/sys/sdt.h:398:9 +pub const NVIM_PROBE = @compileError("unable to translate C expr: expected ')' instead got '...'"); // ./_nvim/src/nvim/log.h:15:10 +pub const LOG = @compileError("unable to translate C expr: expected ')' instead got '...'"); // ./_nvim/src/nvim/log.h:25:9 +pub const DLOG = @compileError("unable to translate C expr: expected ')' instead got '...'"); // ./_nvim/src/nvim/log.h:33:10 +pub const DLOGN = @compileError("unable to translate C expr: expected ')' instead got '...'"); // ./_nvim/src/nvim/log.h:34:10 +pub const ILOG = @compileError("unable to translate C expr: expected ')' instead got '...'"); // ./_nvim/src/nvim/log.h:35:10 +pub const ILOGN = @compileError("unable to translate C expr: expected ')' instead got '...'"); // ./_nvim/src/nvim/log.h:36:10 +pub const WLOG = @compileError("unable to translate C expr: expected ')' instead got '...'"); // ./_nvim/src/nvim/log.h:39:9 +pub const WLOGN = @compileError("unable to translate C expr: expected ')' instead got '...'"); // ./_nvim/src/nvim/log.h:40:9 +pub const ELOG = @compileError("unable to translate C expr: expected ')' instead got '...'"); // ./_nvim/src/nvim/log.h:41:9 +pub const ELOGN = @compileError("unable to translate C expr: expected ')' instead got '...'"); // ./_nvim/src/nvim/log.h:42:9 +pub const LOG_CALLSTACK = @compileError("unable to translate macro: undefined identifier `__func__`"); // ./_nvim/src/nvim/log.h:45:10 +pub const LOG_CALLSTACK_TO_FILE = @compileError("unable to translate macro: undefined identifier `__func__`"); // ./_nvim/src/nvim/log.h:46:10 +pub const GA_EMPTY_INIT_VALUE = @compileError("unable to translate C expr: unexpected token '{'"); // ./_nvim/src/nvim/garray.h:22:9 +pub const GA_INIT = @compileError("unable to translate C expr: unexpected token '{'"); // ./_nvim/src/nvim/garray.h:23:9 +pub const GA_APPEND = @compileError("unable to translate C expr: unexpected token 'do'"); // ./_nvim/src/nvim/garray.h:27:9 +pub const GA_DEEP_CLEAR = @compileError("unable to translate macro: undefined identifier `_gap`"); // ./_nvim/src/nvim/garray.h:56:9 +pub const HASHTAB_ITER = @compileError("unable to translate macro: undefined identifier `ht_`"); // ./_nvim/src/nvim/hashtab.h:80:9 +pub const QUEUE_DATA = @compileError("unable to translate C expr: unexpected token ')'"); // ./_nvim/src/nvim/lib/queue.h:33:9 +pub const QUEUE_FOREACH = @compileError("unable to translate macro: undefined identifier `next`"); // ./_nvim/src/nvim/lib/queue.h:39:9 +pub const CALLBACK_INIT = @compileError("unable to translate C expr: unexpected token '{'"); // _nvim/src/nvim/eval/typval_defs.h:72:9 +pub const TV_INITIAL_VALUE = @compileError("unable to translate C expr: expected '.' instead got '}'"); // _nvim/src/nvim/eval/typval_defs.h:135:9 +pub const TV_LIST_STATIC10_INIT = @compileError("unable to translate C expr: unexpected token '{'"); // _nvim/src/nvim/eval/typval_defs.h:191:9 +pub const TV_DICTITEM_STRUCT = @compileError("unable to translate C expr: expected ')' instead got '...'"); // _nvim/src/nvim/eval/typval_defs.h:205:9 +pub const MBYTE_NONE_CONV = @compileError("unable to translate C expr: unexpected token '{'"); // ./_nvim/src/nvim/mbyte_defs.h:39:9 +pub const SCREEN_GRID_INIT = @compileError("unable to translate C expr: unexpected token '{'"); // ./_nvim/src/nvim/grid_defs.h:109:9 +pub const list_log = @compileError("unable to translate C expr: expected ')' instead got '...'"); // _nvim/src/nvim/eval/typval.h:84:10 +pub const list_write_log = @compileError("unable to translate C expr: expected ')' instead got '...'"); // _nvim/src/nvim/eval/typval.h:85:10 +pub const list_free_log = @compileError("unable to translate C expr: unexpected token 'Eof'"); // _nvim/src/nvim/eval/typval.h:86:10 +pub const TV_DICT_HI2DI = @compileError("unable to translate macro: undefined identifier `di_key`"); // _nvim/src/nvim/eval/typval.h:93:9 +pub const _TV_LIST_ITER_MOD = @compileError("unable to translate macro: undefined identifier `l_`"); // _nvim/src/nvim/eval/typval.h:416:9 +pub const TV_LIST_ITER = @compileError("unable to translate C expr: unexpected token ','"); // _nvim/src/nvim/eval/typval.h:436:9 +pub const TV_LIST_ITER_CONST = @compileError("unable to translate C expr: unexpected token 'const'"); // _nvim/src/nvim/eval/typval.h:447:9 +pub const TV_DICT_ITER = @compileError("unable to translate macro: undefined identifier `hi_`"); // _nvim/src/nvim/eval/typval.h:484:9 +pub const HLATTRS_INIT = @compileError("unable to translate C expr: expected '.' instead got '}'"); // ./_nvim/src/nvim/highlight_defs.h:46:9 +pub const COLOR_ITEM_INITIALIZER = @compileError("unable to translate C expr: unexpected token '{'"); // ./_nvim/src/nvim/highlight_defs.h:245:9 +pub const kh_inline = @compileError("unable to translate C expr: unexpected token 'inline'"); // _nvim/src/klib/khash.h:152:10 +pub const __ac_set_isdel_false = @compileError("unable to translate C expr: expected ')' instead got '&='"); // _nvim/src/klib/khash.h:161:9 +pub const __ac_set_isempty_false = @compileError("unable to translate C expr: expected ')' instead got '&='"); // _nvim/src/klib/khash.h:162:9 +pub const __ac_set_isboth_false = @compileError("unable to translate C expr: expected ')' instead got '&='"); // _nvim/src/klib/khash.h:163:9 +pub const __ac_set_isdel_true = @compileError("unable to translate C expr: expected ')' instead got '|='"); // _nvim/src/klib/khash.h:164:9 +pub const kroundup32 = @compileError("TODO unary inc/dec expr"); // _nvim/src/klib/khash.h:169:10 +pub const __KHASH_TYPE = @compileError("unable to translate macro: undefined identifier `n_buckets`"); // _nvim/src/klib/khash.h:188:9 +pub const __KHASH_PROTOTYPES = @compileError("unable to translate macro: undefined identifier `kh_`"); // _nvim/src/klib/khash.h:196:9 +pub const __KHASH_IMPL = @compileError("unable to translate macro: undefined identifier `kh_`"); // _nvim/src/klib/khash.h:206:9 +pub const KHASH_DECLARE = @compileError("unable to translate C expr: unexpected token 'Identifier'"); // _nvim/src/klib/khash.h:419:9 +pub const KHASH_INIT2 = @compileError("unable to translate C expr: unexpected token 'Identifier'"); // _nvim/src/klib/khash.h:423:9 +pub const KHASH_INIT = @compileError("unable to translate C expr: unexpected token 'static'"); // _nvim/src/klib/khash.h:427:9 +pub const kh_int_hash_func2 = @compileError("unable to translate macro: undefined identifier `key`"); // _nvim/src/klib/khash.h:486:9 +pub const khash_t = @compileError("unable to translate macro: undefined identifier `kh_`"); // _nvim/src/klib/khash.h:496:9 +pub const kh_init = @compileError("unable to translate macro: undefined identifier `kh_init_`"); // _nvim/src/klib/khash.h:503:9 +pub const kh_destroy = @compileError("unable to translate macro: undefined identifier `kh_destroy_`"); // _nvim/src/klib/khash.h:510:9 +pub const kh_dealloc = @compileError("unable to translate macro: undefined identifier `kh_dealloc_`"); // _nvim/src/klib/khash.h:517:9 +pub const kh_clear = @compileError("unable to translate macro: undefined identifier `kh_clear_`"); // _nvim/src/klib/khash.h:524:9 +pub const kh_resize = @compileError("unable to translate macro: undefined identifier `kh_resize_`"); // _nvim/src/klib/khash.h:532:9 +pub const kh_put = @compileError("unable to translate macro: undefined identifier `kh_put_`"); // _nvim/src/klib/khash.h:545:9 +pub const kh_get = @compileError("unable to translate macro: undefined identifier `kh_get_`"); // _nvim/src/klib/khash.h:554:9 +pub const kh_del = @compileError("unable to translate macro: undefined identifier `kh_del_`"); // _nvim/src/klib/khash.h:562:9 +pub const kh_foreach = @compileError("unable to translate macro: undefined identifier `__i`"); // _nvim/src/klib/khash.h:629:9 +pub const kh_foreach_value = @compileError("unable to translate macro: undefined identifier `__i`"); // _nvim/src/klib/khash.h:643:9 +pub const kh_foreach_key = @compileError("unable to translate macro: undefined identifier `__i`"); // _nvim/src/klib/khash.h:656:9 +pub const KHASH_EMPTY_TABLE = @compileError("unable to translate macro: undefined identifier `kh_`"); // _nvim/src/klib/khash.h:720:9 +pub const Map = @compileError("unable to translate macro: undefined identifier `Map_`"); // ./_nvim/src/nvim/map_defs.h:9:9 +pub const MAP_DECLS = @compileError("unable to translate macro: undefined identifier `_map`"); // ./_nvim/src/nvim/map.h:23:9 +pub const MAP_INIT = @compileError("unable to translate C expr: unexpected token '{'"); // ./_nvim/src/nvim/map.h:63:9 +pub const map_init = @compileError("unable to translate C expr: unexpected token 'do'"); // ./_nvim/src/nvim/map.h:64:9 +pub const map_destroy = @compileError("unable to translate macro: undefined identifier `map_`"); // ./_nvim/src/nvim/map.h:66:9 +pub const map_get = @compileError("unable to translate macro: undefined identifier `map_`"); // ./_nvim/src/nvim/map.h:67:9 +pub const map_has = @compileError("unable to translate macro: undefined identifier `map_`"); // ./_nvim/src/nvim/map.h:68:9 +pub const map_key = @compileError("unable to translate macro: undefined identifier `map_`"); // ./_nvim/src/nvim/map.h:69:9 +pub const map_put = @compileError("unable to translate macro: undefined identifier `map_`"); // ./_nvim/src/nvim/map.h:70:9 +pub const map_ref = @compileError("unable to translate macro: undefined identifier `map_`"); // ./_nvim/src/nvim/map.h:71:9 +pub const map_del = @compileError("unable to translate macro: undefined identifier `map_`"); // ./_nvim/src/nvim/map.h:72:9 +pub const map_clear = @compileError("unable to translate macro: undefined identifier `map_`"); // ./_nvim/src/nvim/map.h:73:9 +pub const INIT_FMARKV = @compileError("unable to translate C expr: unexpected token '{'"); // ./_nvim/src/nvim/mark_defs.h:68:9 +pub const INIT_FMARK = @compileError("unable to translate C expr: unexpected token '{'"); // ./_nvim/src/nvim/mark_defs.h:79:9 +pub const INIT_XFMARK = @compileError("unable to translate C expr: unexpected token '{'"); // ./_nvim/src/nvim/mark_defs.h:87:9 +pub const STATIC_ASSERT = @compileError("unable to translate C expr: unexpected token 'do'"); // ./_nvim/src/nvim/assert.h:51:9 +pub const STATIC_ASSERT_STATEMENT = @compileError("unable to translate C expr: unexpected token '_Static_assert'"); // ./_nvim/src/nvim/assert.h:61:10 +pub const ASSERT_CONCAT_ = @compileError("unable to translate C expr: unexpected token '##'"); // ./_nvim/src/nvim/assert.h:111:9 +pub const STATIC_ASSERT_EXPR = @compileError("unable to translate macro: undefined identifier `static_assert_`"); // ./_nvim/src/nvim/assert.h:115:10 +pub const STRICT_ADD = @compileError("unable to translate macro: undefined identifier `__builtin_add_overflow`"); // ./_nvim/src/nvim/assert.h:141:10 +pub const STRICT_SUB = @compileError("unable to translate macro: undefined identifier `__builtin_sub_overflow`"); // ./_nvim/src/nvim/assert.h:157:10 +pub const MT_INVALID_KEY = @compileError("unable to translate C expr: unexpected token '{'"); // ./_nvim/src/nvim/marktree.h:58:9 +pub const SHM_ALL_ABBREVIATIONS = @compileError("unable to translate C expr: expected ')' instead got '['"); // ./_nvim/src/nvim/option_defs.h:266:9 +pub const STL_ALL = @compileError("unable to translate C expr: expected ')' instead got '['"); // ./_nvim/src/nvim/option_defs.h:353:9 +pub const SGN_KEY_OFF = @compileError("unable to translate macro: undefined identifier `sg_name`"); // ./_nvim/src/nvim/sign_defs.h:19:9 +pub const bh_bnum = @compileError("unable to translate macro: undefined identifier `bh_hashitem`"); // ./_nvim/src/nvim/memfile_defs.h:65:9 +pub const nt_old_bnum = @compileError("unable to translate macro: undefined identifier `nt_hashitem`"); // ./_nvim/src/nvim/memfile_defs.h:85:9 +pub const UV_EXTERN = @compileError("unable to translate macro: undefined identifier `__attribute__`"); // /usr/include/uv.h:47:10 +pub const d_fileno = @compileError("unable to translate macro: undefined identifier `d_ino`"); // /usr/include/bits/dirent.h:47:9 +pub const __SOCKADDR_COMMON = @compileError("unable to translate macro: undefined identifier `family`"); // /usr/include/bits/sockaddr.h:34:9 +pub const __struct_group = @compileError("unable to translate C expr: expected ')' instead got '...'"); // /usr/include/linux/stddef.h:26:9 +pub const __DECLARE_FLEX_ARRAY = @compileError("unable to translate macro: undefined identifier `__empty_`"); // /usr/include/linux/stddef.h:42:9 +pub const __SOCKADDR_ARG = @compileError("unable to translate macro: undefined identifier `__restrict`"); // /usr/include/sys/socket.h:58:10 +pub const __CONST_SOCKADDR_ARG = @compileError("unable to translate C expr: unexpected token 'const'"); // /usr/include/sys/socket.h:59:10 +pub const SCM_SRCRT = @compileError("unable to translate macro: undefined identifier `IPV6_RXSRCRT`"); // /usr/include/bits/in.h:170:9 +pub const s6_addr = @compileError("unable to translate macro: undefined identifier `__in6_u`"); // /usr/include/netinet/in.h:229:9 +pub const s6_addr16 = @compileError("unable to translate macro: undefined identifier `__in6_u`"); // /usr/include/netinet/in.h:231:10 +pub const s6_addr32 = @compileError("unable to translate macro: undefined identifier `__in6_u`"); // /usr/include/netinet/in.h:232:10 +pub const IN6ADDR_ANY_INIT = @compileError("unable to translate C expr: unexpected token '{'"); // /usr/include/netinet/in.h:239:9 +pub const IN6ADDR_LOOPBACK_INIT = @compileError("unable to translate C expr: unexpected token '{'"); // /usr/include/netinet/in.h:240:9 +pub const IN6_IS_ADDR_UNSPECIFIED = @compileError("unable to translate macro: undefined identifier `__extension__`"); // /usr/include/netinet/in.h:433:10 +pub const IN6_IS_ADDR_LOOPBACK = @compileError("unable to translate macro: undefined identifier `__extension__`"); // /usr/include/netinet/in.h:441:10 +pub const IN6_IS_ADDR_LINKLOCAL = @compileError("unable to translate macro: undefined identifier `__extension__`"); // /usr/include/netinet/in.h:449:10 +pub const IN6_IS_ADDR_SITELOCAL = @compileError("unable to translate macro: undefined identifier `__extension__`"); // /usr/include/netinet/in.h:454:10 +pub const IN6_IS_ADDR_V4MAPPED = @compileError("unable to translate macro: undefined identifier `__extension__`"); // /usr/include/netinet/in.h:459:10 +pub const IN6_IS_ADDR_V4COMPAT = @compileError("unable to translate macro: undefined identifier `__extension__`"); // /usr/include/netinet/in.h:466:10 +pub const IN6_ARE_ADDR_EQUAL = @compileError("unable to translate macro: undefined identifier `__extension__`"); // /usr/include/netinet/in.h:474:10 +pub const IN6_IS_ADDR_MULTICAST = @compileError("unable to translate C expr: unexpected token 'const'"); // /usr/include/netinet/in.h:521:9 +pub const IN6_IS_ADDR_MC_NODELOCAL = @compileError("unable to translate C expr: unexpected token 'const'"); // /usr/include/netinet/in.h:533:9 +pub const IN6_IS_ADDR_MC_LINKLOCAL = @compileError("unable to translate C expr: unexpected token 'const'"); // /usr/include/netinet/in.h:537:9 +pub const IN6_IS_ADDR_MC_SITELOCAL = @compileError("unable to translate C expr: unexpected token 'const'"); // /usr/include/netinet/in.h:541:9 +pub const IN6_IS_ADDR_MC_ORGLOCAL = @compileError("unable to translate C expr: unexpected token 'const'"); // /usr/include/netinet/in.h:545:9 +pub const IN6_IS_ADDR_MC_GLOBAL = @compileError("unable to translate C expr: unexpected token 'const'"); // /usr/include/netinet/in.h:549:9 +pub const h_addr = @compileError("unable to translate macro: undefined identifier `h_addr_list`"); // /usr/include/netdb.h:106:10 +pub const __CPU_ZERO_S = @compileError("unable to translate C expr: unexpected token 'do'"); // /usr/include/bits/cpu-set.h:46:10 +pub const __CPU_SET_S = @compileError("unable to translate macro: undefined identifier `__extension__`"); // /usr/include/bits/cpu-set.h:58:9 +pub const __CPU_CLR_S = @compileError("unable to translate macro: undefined identifier `__extension__`"); // /usr/include/bits/cpu-set.h:65:9 +pub const __CPU_ISSET_S = @compileError("unable to translate macro: undefined identifier `__extension__`"); // /usr/include/bits/cpu-set.h:72:9 +pub const __CPU_EQUAL_S = @compileError("unable to translate macro: undefined identifier `__builtin_memcmp`"); // /usr/include/bits/cpu-set.h:84:10 +pub const __CPU_OP_S = @compileError("unable to translate macro: undefined identifier `__extension__`"); // /usr/include/bits/cpu-set.h:99:9 +pub const __sched_priority = @compileError("unable to translate macro: undefined identifier `sched_priority`"); // /usr/include/sched.h:48:9 +pub const PTHREAD_MUTEX_INITIALIZER = @compileError("unable to translate C expr: unexpected token '{'"); // /usr/include/pthread.h:90:9 +pub const PTHREAD_RWLOCK_INITIALIZER = @compileError("unable to translate C expr: unexpected token '{'"); // /usr/include/pthread.h:114:10 +pub const PTHREAD_COND_INITIALIZER = @compileError("unable to translate C expr: unexpected token '{'"); // /usr/include/pthread.h:155:9 +pub const pthread_cleanup_push = @compileError("unable to translate macro: undefined identifier `__cancel_buf`"); // /usr/include/pthread.h:681:10 +pub const pthread_cleanup_pop = @compileError("unable to translate macro: undefined identifier `__cancel_buf`"); // /usr/include/pthread.h:702:10 +pub const UV_PLATFORM_LOOP_FIELDS = @compileError("unable to translate macro: undefined identifier `inotify_read_watcher`"); // /usr/include/uv/linux.h:25:9 +pub const UV_PLATFORM_FS_EVENT_FIELDS = @compileError("unable to translate macro: undefined identifier `watchers`"); // /usr/include/uv/linux.h:30:9 +pub const UV_DIR_PRIVATE_FIELDS = @compileError("unable to translate macro: undefined identifier `dir`"); // /usr/include/uv/unix.h:171:9 +pub const UV_LOOP_PRIVATE_FIELDS = @compileError("unable to translate macro: undefined identifier `flags`"); // /usr/include/uv/unix.h:221:9 +pub const UV_WRITE_PRIVATE_FIELDS = @compileError("unable to translate macro: undefined identifier `queue`"); // /usr/include/uv/unix.h:260:9 +pub const UV_CONNECT_PRIVATE_FIELDS = @compileError("unable to translate macro: undefined identifier `queue`"); // /usr/include/uv/unix.h:268:9 +pub const UV_UDP_SEND_PRIVATE_FIELDS = @compileError("unable to translate macro: undefined identifier `queue`"); // /usr/include/uv/unix.h:273:9 +pub const UV_HANDLE_PRIVATE_FIELDS = @compileError("unable to translate macro: undefined identifier `next_closing`"); // /usr/include/uv/unix.h:282:9 +pub const UV_STREAM_PRIVATE_FIELDS = @compileError("unable to translate macro: undefined identifier `connect_req`"); // /usr/include/uv/unix.h:286:9 +pub const UV_UDP_PRIVATE_FIELDS = @compileError("unable to translate macro: undefined identifier `alloc_cb`"); // /usr/include/uv/unix.h:300:9 +pub const UV_PIPE_PRIVATE_FIELDS = @compileError("unable to translate macro: undefined identifier `pipe_fname`"); // /usr/include/uv/unix.h:307:9 +pub const UV_POLL_PRIVATE_FIELDS = @compileError("unable to translate macro: undefined identifier `io_watcher`"); // /usr/include/uv/unix.h:310:9 +pub const UV_PREPARE_PRIVATE_FIELDS = @compileError("unable to translate macro: undefined identifier `prepare_cb`"); // /usr/include/uv/unix.h:313:9 +pub const UV_CHECK_PRIVATE_FIELDS = @compileError("unable to translate macro: undefined identifier `check_cb`"); // /usr/include/uv/unix.h:317:9 +pub const UV_IDLE_PRIVATE_FIELDS = @compileError("unable to translate macro: undefined identifier `idle_cb`"); // /usr/include/uv/unix.h:321:9 +pub const UV_ASYNC_PRIVATE_FIELDS = @compileError("unable to translate macro: undefined identifier `async_cb`"); // /usr/include/uv/unix.h:325:9 +pub const UV_TIMER_PRIVATE_FIELDS = @compileError("unable to translate macro: undefined identifier `timer_cb`"); // /usr/include/uv/unix.h:330:9 +pub const UV_GETADDRINFO_PRIVATE_FIELDS = @compileError("unable to translate macro: undefined identifier `work_req`"); // /usr/include/uv/unix.h:337:9 +pub const UV_GETNAMEINFO_PRIVATE_FIELDS = @compileError("unable to translate macro: undefined identifier `work_req`"); // /usr/include/uv/unix.h:346:9 +pub const UV_PROCESS_PRIVATE_FIELDS = @compileError("unable to translate macro: undefined identifier `queue`"); // /usr/include/uv/unix.h:355:9 +pub const UV_FS_PRIVATE_FIELDS = @compileError("unable to translate macro: undefined identifier `new_path`"); // /usr/include/uv/unix.h:359:9 +pub const UV_WORK_PRIVATE_FIELDS = @compileError("unable to translate macro: undefined identifier `work_req`"); // /usr/include/uv/unix.h:374:9 +pub const UV_TTY_PRIVATE_FIELDS = @compileError("unable to translate macro: undefined identifier `orig_termios`"); // /usr/include/uv/unix.h:377:9 +pub const UV_SIGNAL_PRIVATE_FIELDS = @compileError("unable to translate macro: undefined identifier `rbe_left`"); // /usr/include/uv/unix.h:381:9 +pub const UV_FS_EVENT_PRIVATE_FIELDS = @compileError("unable to translate macro: undefined identifier `cb`"); // /usr/include/uv/unix.h:393:9 +pub const UV_ERRNO_MAP = @compileError("unable to translate macro: undefined identifier `EAI_ADDRFAMILY`"); // /usr/include/uv.h:72:9 +pub const UV_HANDLE_TYPE_MAP = @compileError("unable to translate macro: undefined identifier `ASYNC`"); // /usr/include/uv.h:156:9 +pub const UV_REQ_TYPE_MAP = @compileError("unable to translate macro: undefined identifier `REQ`"); // /usr/include/uv.h:174:9 +pub const XX = @compileError("unable to translate macro: undefined identifier `UV_`"); // /usr/include/uv.h:187:9 +pub const UV_REQ_FIELDS = @compileError("unable to translate macro: undefined identifier `data`"); // /usr/include/uv.h:401:9 +pub const UV_HANDLE_FIELDS = @compileError("unable to translate macro: undefined identifier `data`"); // /usr/include/uv.h:432:9 +pub const UV_STREAM_FIELDS = @compileError("unable to translate macro: undefined identifier `write_queue_size`"); // /usr/include/uv.h:489:9 +pub const w_p_arab = @compileError("unable to translate macro: undefined identifier `w_onebuf_opt`"); // ./_nvim/src/nvim/buffer_defs.h:132:9 +pub const w_p_bri = @compileError("unable to translate macro: undefined identifier `w_onebuf_opt`"); // ./_nvim/src/nvim/buffer_defs.h:134:9 +pub const w_p_briopt = @compileError("unable to translate macro: undefined identifier `w_onebuf_opt`"); // ./_nvim/src/nvim/buffer_defs.h:136:9 +pub const w_p_diff = @compileError("unable to translate macro: undefined identifier `w_onebuf_opt`"); // ./_nvim/src/nvim/buffer_defs.h:138:9 +pub const w_p_fdc = @compileError("unable to translate macro: undefined identifier `w_onebuf_opt`"); // ./_nvim/src/nvim/buffer_defs.h:140:9 +pub const w_p_fdc_save = @compileError("unable to translate macro: undefined identifier `w_onebuf_opt`"); // ./_nvim/src/nvim/buffer_defs.h:142:9 +pub const w_p_fen = @compileError("unable to translate macro: undefined identifier `w_onebuf_opt`"); // ./_nvim/src/nvim/buffer_defs.h:144:9 +pub const w_p_fen_save = @compileError("unable to translate macro: undefined identifier `w_onebuf_opt`"); // ./_nvim/src/nvim/buffer_defs.h:147:9 +pub const w_p_fdi = @compileError("unable to translate macro: undefined identifier `w_onebuf_opt`"); // ./_nvim/src/nvim/buffer_defs.h:149:9 +pub const w_p_fdl = @compileError("unable to translate macro: undefined identifier `w_onebuf_opt`"); // ./_nvim/src/nvim/buffer_defs.h:151:9 +pub const w_p_fdl_save = @compileError("unable to translate macro: undefined identifier `w_onebuf_opt`"); // ./_nvim/src/nvim/buffer_defs.h:154:9 +pub const w_p_fdm = @compileError("unable to translate macro: undefined identifier `w_onebuf_opt`"); // ./_nvim/src/nvim/buffer_defs.h:156:9 +pub const w_p_fdm_save = @compileError("unable to translate macro: undefined identifier `w_onebuf_opt`"); // ./_nvim/src/nvim/buffer_defs.h:158:9 +pub const w_p_fml = @compileError("unable to translate macro: undefined identifier `w_onebuf_opt`"); // ./_nvim/src/nvim/buffer_defs.h:160:9 +pub const w_p_fdn = @compileError("unable to translate macro: undefined identifier `w_onebuf_opt`"); // ./_nvim/src/nvim/buffer_defs.h:162:9 +pub const w_p_fde = @compileError("unable to translate macro: undefined identifier `w_onebuf_opt`"); // ./_nvim/src/nvim/buffer_defs.h:164:9 +pub const w_p_fdt = @compileError("unable to translate macro: undefined identifier `w_onebuf_opt`"); // ./_nvim/src/nvim/buffer_defs.h:166:9 +pub const w_p_fmr = @compileError("unable to translate macro: undefined identifier `w_onebuf_opt`"); // ./_nvim/src/nvim/buffer_defs.h:168:9 +pub const w_p_lbr = @compileError("unable to translate macro: undefined identifier `w_onebuf_opt`"); // ./_nvim/src/nvim/buffer_defs.h:170:9 +pub const w_p_list = @compileError("unable to translate macro: undefined identifier `w_onebuf_opt`"); // ./_nvim/src/nvim/buffer_defs.h:172:9 +pub const w_p_nu = @compileError("unable to translate macro: undefined identifier `w_onebuf_opt`"); // ./_nvim/src/nvim/buffer_defs.h:174:9 +pub const w_p_rnu = @compileError("unable to translate macro: undefined identifier `w_onebuf_opt`"); // ./_nvim/src/nvim/buffer_defs.h:176:9 +pub const w_p_ve = @compileError("unable to translate macro: undefined identifier `w_onebuf_opt`"); // ./_nvim/src/nvim/buffer_defs.h:178:9 +pub const w_ve_flags = @compileError("unable to translate macro: undefined identifier `w_onebuf_opt`"); // ./_nvim/src/nvim/buffer_defs.h:180:9 +pub const w_p_nuw = @compileError("unable to translate macro: undefined identifier `w_onebuf_opt`"); // ./_nvim/src/nvim/buffer_defs.h:182:9 +pub const w_p_wfh = @compileError("unable to translate macro: undefined identifier `w_onebuf_opt`"); // ./_nvim/src/nvim/buffer_defs.h:184:9 +pub const w_p_wfw = @compileError("unable to translate macro: undefined identifier `w_onebuf_opt`"); // ./_nvim/src/nvim/buffer_defs.h:186:9 +pub const w_p_pvw = @compileError("unable to translate macro: undefined identifier `w_onebuf_opt`"); // ./_nvim/src/nvim/buffer_defs.h:188:9 +pub const w_p_rl = @compileError("unable to translate macro: undefined identifier `w_onebuf_opt`"); // ./_nvim/src/nvim/buffer_defs.h:190:9 +pub const w_p_rlc = @compileError("unable to translate macro: undefined identifier `w_onebuf_opt`"); // ./_nvim/src/nvim/buffer_defs.h:192:9 +pub const w_p_scr = @compileError("unable to translate macro: undefined identifier `w_onebuf_opt`"); // ./_nvim/src/nvim/buffer_defs.h:194:9 +pub const w_p_spell = @compileError("unable to translate macro: undefined identifier `w_onebuf_opt`"); // ./_nvim/src/nvim/buffer_defs.h:196:9 +pub const w_p_cuc = @compileError("unable to translate macro: undefined identifier `w_onebuf_opt`"); // ./_nvim/src/nvim/buffer_defs.h:198:9 +pub const w_p_cul = @compileError("unable to translate macro: undefined identifier `w_onebuf_opt`"); // ./_nvim/src/nvim/buffer_defs.h:200:9 +pub const w_p_culopt = @compileError("unable to translate macro: undefined identifier `w_onebuf_opt`"); // ./_nvim/src/nvim/buffer_defs.h:202:9 +pub const w_p_cc = @compileError("unable to translate macro: undefined identifier `w_onebuf_opt`"); // ./_nvim/src/nvim/buffer_defs.h:204:9 +pub const w_p_sbr = @compileError("unable to translate macro: undefined identifier `w_onebuf_opt`"); // ./_nvim/src/nvim/buffer_defs.h:206:9 +pub const w_p_stc = @compileError("unable to translate macro: undefined identifier `w_onebuf_opt`"); // ./_nvim/src/nvim/buffer_defs.h:208:9 +pub const w_p_stl = @compileError("unable to translate macro: undefined identifier `w_onebuf_opt`"); // ./_nvim/src/nvim/buffer_defs.h:210:9 +pub const w_p_wbr = @compileError("unable to translate macro: undefined identifier `w_onebuf_opt`"); // ./_nvim/src/nvim/buffer_defs.h:212:9 +pub const w_p_scb = @compileError("unable to translate macro: undefined identifier `w_onebuf_opt`"); // ./_nvim/src/nvim/buffer_defs.h:214:9 +pub const w_p_diff_saved = @compileError("unable to translate macro: undefined identifier `w_onebuf_opt`"); // ./_nvim/src/nvim/buffer_defs.h:216:9 +pub const w_p_scb_save = @compileError("unable to translate macro: undefined identifier `w_onebuf_opt`"); // ./_nvim/src/nvim/buffer_defs.h:218:9 +pub const w_p_wrap = @compileError("unable to translate macro: undefined identifier `w_onebuf_opt`"); // ./_nvim/src/nvim/buffer_defs.h:220:9 +pub const w_p_wrap_save = @compileError("unable to translate macro: undefined identifier `w_onebuf_opt`"); // ./_nvim/src/nvim/buffer_defs.h:222:9 +pub const w_p_cocu = @compileError("unable to translate macro: undefined identifier `w_onebuf_opt`"); // ./_nvim/src/nvim/buffer_defs.h:224:9 +pub const w_p_cole = @compileError("unable to translate macro: undefined identifier `w_onebuf_opt`"); // ./_nvim/src/nvim/buffer_defs.h:226:9 +pub const w_p_crb = @compileError("unable to translate macro: undefined identifier `w_onebuf_opt`"); // ./_nvim/src/nvim/buffer_defs.h:228:9 +pub const w_p_crb_save = @compileError("unable to translate macro: undefined identifier `w_onebuf_opt`"); // ./_nvim/src/nvim/buffer_defs.h:230:9 +pub const w_p_scl = @compileError("unable to translate macro: undefined identifier `w_onebuf_opt`"); // ./_nvim/src/nvim/buffer_defs.h:232:9 +pub const w_p_winhl = @compileError("unable to translate macro: undefined identifier `w_onebuf_opt`"); // ./_nvim/src/nvim/buffer_defs.h:234:9 +pub const w_p_lcs = @compileError("unable to translate macro: undefined identifier `w_onebuf_opt`"); // ./_nvim/src/nvim/buffer_defs.h:236:9 +pub const w_p_fcs = @compileError("unable to translate macro: undefined identifier `w_onebuf_opt`"); // ./_nvim/src/nvim/buffer_defs.h:238:9 +pub const w_p_winbl = @compileError("unable to translate macro: undefined identifier `w_onebuf_opt`"); // ./_nvim/src/nvim/buffer_defs.h:240:9 +pub const w_p_script_ctx = @compileError("unable to translate macro: undefined identifier `w_onebuf_opt`"); // ./_nvim/src/nvim/buffer_defs.h:243:9 +pub const BUF_UPDATE_CALLBACKS_INIT = @compileError("unable to translate C expr: unexpected token '{'"); // ./_nvim/src/nvim/buffer_defs.h:442:9 +pub const b_fnum = @compileError("unable to translate macro: undefined identifier `handle`"); // ./_nvim/src/nvim/buffer_defs.h:461:9 +pub const FLOAT_CONFIG_INIT = @compileError("unable to translate C expr: unexpected token '{'"); // ./_nvim/src/nvim/buffer_defs.h:1042:9 +pub const CHANGEDTICK = @compileError("unable to translate macro: undefined identifier `Include`"); // ./_nvim/src/nvim/buffer_defs.h:1398:9 +pub const DECORATION_INIT = @compileError("unable to translate C expr: unexpected token '{'"); // ./_nvim/src/nvim/decoration.h:71:9 +pub const AUCMD_EXECUTABLE_INIT = @compileError("unable to translate C expr: unexpected token '{'"); // ./_nvim/src/nvim/ex_cmds_defs.h:125:9 +pub const cs_rettv = @compileError("unable to translate macro: undefined identifier `cs_pend`"); // ./_nvim/src/nvim/ex_cmds_defs.h:168:9 +pub const cs_exception = @compileError("unable to translate macro: undefined identifier `cs_pend`"); // ./_nvim/src/nvim/ex_cmds_defs.h:169:9 +pub const VA_EVENT_INIT = @compileError("unable to translate macro: undefined identifier `args`"); // ./_nvim/src/nvim/event/defs.h:16:9 +pub const multiqueue_put = @compileError("unable to translate C expr: expected ')' instead got '...'"); // ./_nvim/src/nvim/event/multiqueue.h:12:9 +pub const KMEMPOOL_INIT = @compileError("unable to translate macro: undefined identifier `cnt`"); // _nvim/src/klib/klist.h:35:9 +pub const kmempool_t = @compileError("unable to translate macro: undefined identifier `kmp_`"); // _nvim/src/klib/klist.h:68:9 +pub const kmp_init = @compileError("unable to translate macro: undefined identifier `kmp_init_`"); // _nvim/src/klib/klist.h:69:9 +pub const kmp_destroy = @compileError("unable to translate macro: undefined identifier `kmp_destroy_`"); // _nvim/src/klib/klist.h:70:9 +pub const kmp_alloc = @compileError("unable to translate macro: undefined identifier `kmp_alloc_`"); // _nvim/src/klib/klist.h:71:9 +pub const kmp_free = @compileError("unable to translate macro: undefined identifier `kmp_free_`"); // _nvim/src/klib/klist.h:72:9 +pub const KLIST_INIT = @compileError("unable to translate macro: undefined identifier `__kl1_`"); // _nvim/src/klib/klist.h:74:9 +pub const kliter_t = @compileError("unable to translate macro: undefined identifier `kl1_`"); // _nvim/src/klib/klist.h:125:9 +pub const klist_t = @compileError("unable to translate macro: undefined identifier `kl_`"); // _nvim/src/klib/klist.h:126:9 +pub const kl_init = @compileError("unable to translate macro: undefined identifier `kl_init_`"); // _nvim/src/klib/klist.h:132:9 +pub const kl_destroy = @compileError("unable to translate macro: undefined identifier `kl_destroy_`"); // _nvim/src/klib/klist.h:133:9 +pub const kl_push = @compileError("unable to translate macro: undefined identifier `kl_push_`"); // _nvim/src/klib/klist.h:134:9 +pub const kl_shift_at = @compileError("unable to translate macro: undefined identifier `kl_shift_at_`"); // _nvim/src/klib/klist.h:135:9 +pub const kl_iter_at = @compileError("unable to translate macro: undefined identifier `kl1_`"); // _nvim/src/klib/klist.h:141:9 +pub const _NOOP = @compileError("unable to translate C expr: unexpected token 'Eof'"); // ./_nvim/src/nvim/event/loop.h:13:9 +pub const CREATE_EVENT = @compileError("unable to translate C expr: expected ')' instead got '...'"); // ./_nvim/src/nvim/event/loop.h:46:9 +pub const LOOP_PROCESS_EVENTS_UNTIL = @compileError("unable to translate macro: undefined identifier `remaining`"); // ./_nvim/src/nvim/event/loop.h:59:9 +pub const LOOP_PROCESS_EVENTS = @compileError("unable to translate C expr: unexpected token 'do'"); // ./_nvim/src/nvim/event/loop.h:78:9 +pub const FOR_ALL_AUEVENTS = @compileError("unable to translate C expr: unexpected token 'for'"); // ./_nvim/src/nvim/autocmd.h:102:9 +pub const SCRIPT_ITEM = @compileError("unable to translate C expr: expected ')' instead got '*'"); // ./_nvim/src/nvim/runtime.h:90:9 +pub const FOR_ALL_FRAMES = @compileError("unable to translate C expr: unexpected token 'for'"); // ./_nvim/src/nvim/globals.h:410:9 +pub const FOR_ALL_TAB_WINDOWS = @compileError("unable to translate C expr: unexpected token 'Identifier'"); // ./_nvim/src/nvim/globals.h:415:9 +pub const FOR_ALL_WINDOWS_IN_TAB = @compileError("unable to translate C expr: unexpected token 'for'"); // ./_nvim/src/nvim/globals.h:420:9 +pub const FOR_ALL_TABS = @compileError("unable to translate C expr: unexpected token 'for'"); // ./_nvim/src/nvim/globals.h:452:9 +pub const FOR_ALL_BUFFERS = @compileError("unable to translate C expr: unexpected token 'for'"); // ./_nvim/src/nvim/globals.h:461:9 +pub const FOR_ALL_BUFFERS_BACKWARDS = @compileError("unable to translate C expr: unexpected token 'for'"); // ./_nvim/src/nvim/globals.h:463:9 +pub const FOR_ALL_BUF_WININFO = @compileError("unable to translate C expr: unexpected token 'for'"); // ./_nvim/src/nvim/globals.h:466:9 +pub const FOR_ALL_SIGNS_IN_BUF = @compileError("unable to translate C expr: unexpected token 'for'"); // ./_nvim/src/nvim/globals.h:470:9 +pub const RBUFFER_UNTIL_EMPTY = @compileError("unable to translate macro: undefined identifier `_r`"); // ./_nvim/src/nvim/rbuffer.h:43:9 +pub const RBUFFER_UNTIL_FULL = @compileError("unable to translate macro: undefined identifier `_r`"); // ./_nvim/src/nvim/rbuffer.h:49:9 +pub const RBUFFER_EACH = @compileError("unable to translate C expr: unexpected token 'for'"); // ./_nvim/src/nvim/rbuffer.h:56:9 +pub const RBUFFER_EACH_REVERSE = @compileError("unable to translate C expr: unexpected token 'for'"); // ./_nvim/src/nvim/rbuffer.h:64:9 +pub const _msgpack_sync_decr_and_fetch = @compileError("unable to translate macro: undefined identifier `__sync_sub_and_fetch`"); // /usr/include/msgpack/sysdep.h:85:12 +pub const _msgpack_sync_incr_and_fetch = @compileError("unable to translate macro: undefined identifier `__sync_add_and_fetch`"); // /usr/include/msgpack/sysdep.h:86:12 +pub const _msgpack_load16 = @compileError("unable to translate C expr: unexpected token 'do'"); // /usr/include/msgpack/sysdep.h:174:9 +pub const _msgpack_load32 = @compileError("unable to translate C expr: unexpected token 'do'"); // /usr/include/msgpack/sysdep.h:179:9 +pub const _msgpack_load64 = @compileError("unable to translate C expr: unexpected token 'do'"); // /usr/include/msgpack/sysdep.h:183:9 +pub const _msgpack_store16 = @compileError("unable to translate macro: undefined identifier `val`"); // /usr/include/msgpack/sysdep.h:188:9 +pub const _msgpack_store32 = @compileError("unable to translate macro: undefined identifier `val`"); // /usr/include/msgpack/sysdep.h:190:9 +pub const _msgpack_store64 = @compileError("unable to translate macro: undefined identifier `val`"); // /usr/include/msgpack/sysdep.h:192:9 +pub const msgpack_pack_inline_func = @compileError("unable to translate macro: undefined identifier `msgpack_pack`"); // /usr/include/msgpack/pack.h:114:9 +pub const msgpack_pack_inline_func_cint = @compileError("unable to translate macro: undefined identifier `msgpack_pack`"); // /usr/include/msgpack/pack.h:117:9 +pub const msgpack_pack_inline_func_fixint = @compileError("unable to translate macro: undefined identifier `msgpack_pack_fix`"); // /usr/include/msgpack/pack.h:120:9 +pub const msgpack_pack_user = @compileError("unable to translate C expr: unexpected token 'Eof'"); // /usr/include/msgpack/pack.h:123:9 +pub const msgpack_pack_append_buffer = @compileError("unable to translate C expr: unexpected token 'return'"); // /usr/include/msgpack/pack.h:125:9 +pub const msgpack_pack_real_uint8 = @compileError("unable to translate macro: undefined identifier `buf`"); // /usr/include/msgpack/pack_template.h:53:9 +pub const msgpack_pack_real_uint16 = @compileError("unable to translate macro: undefined identifier `buf`"); // /usr/include/msgpack/pack_template.h:65:9 +pub const msgpack_pack_real_uint32 = @compileError("unable to translate macro: undefined identifier `buf`"); // /usr/include/msgpack/pack_template.h:82:9 +pub const msgpack_pack_real_uint64 = @compileError("unable to translate macro: undefined identifier `buf`"); // /usr/include/msgpack/pack_template.h:108:9 +pub const msgpack_pack_real_int8 = @compileError("unable to translate macro: undefined identifier `buf`"); // /usr/include/msgpack/pack_template.h:139:9 +pub const msgpack_pack_real_int16 = @compileError("unable to translate macro: undefined identifier `buf`"); // /usr/include/msgpack/pack_template.h:151:9 +pub const msgpack_pack_real_int32 = @compileError("unable to translate macro: undefined identifier `buf`"); // /usr/include/msgpack/pack_template.h:181:9 +pub const msgpack_pack_real_int64 = @compileError("unable to translate macro: undefined identifier `buf`"); // /usr/include/msgpack/pack_template.h:221:9 +pub const MSGPACK_STR = @compileError("unable to translate C expr: unexpected token '#'"); // /usr/include/msgpack/version.h:28:9 +pub const MSGPACK_VERSION_I = @compileError("unable to translate C expr: unexpected token 'StringLiteral'"); // /usr/include/msgpack/version.h:29:9 +pub const CLEAR_POINTER = @compileError("unable to translate C expr: unexpected token '*'"); // ./_nvim/src/nvim/vim.h:195:9 +pub const TCGETS2 = @compileError("unable to translate macro: undefined identifier `termios2`"); // /usr/include/asm-generic/ioctls.h:61:9 +pub const TCSETS2 = @compileError("unable to translate macro: undefined identifier `termios2`"); // /usr/include/asm-generic/ioctls.h:62:9 +pub const TCSETSW2 = @compileError("unable to translate macro: undefined identifier `termios2`"); // /usr/include/asm-generic/ioctls.h:63:9 +pub const TCSETSF2 = @compileError("unable to translate macro: undefined identifier `termios2`"); // /usr/include/asm-generic/ioctls.h:64:9 +pub const TIOCGISO7816 = @compileError("unable to translate macro: undefined identifier `serial_iso7816`"); // /usr/include/asm-generic/ioctls.h:82:9 +pub const TIOCSISO7816 = @compileError("unable to translate macro: undefined identifier `serial_iso7816`"); // /usr/include/asm-generic/ioctls.h:83:9 +pub const MSGPACK_SBUFFER_INIT = @compileError("unable to translate C expr: expected '.' instead got '}'"); // ./_nvim/src/nvim/context.h:20:9 +pub const CONTEXT_INIT = @compileError("unable to translate C expr: expected '.' instead got '}'"); // ./_nvim/src/nvim/context.h:26:9 +pub const HL_SET_DEFAULT_COLORS = @compileError("unable to translate macro: undefined identifier `dark_`"); // ./_nvim/src/nvim/highlight.h:26:9 +pub const BOOLEAN_OBJ = @compileError("unable to translate C expr: expected '=' instead got '.'"); // _nvim/src/nvim/api/private/helpers.h:20:9 +pub const INTEGER_OBJ = @compileError("unable to translate C expr: expected '=' instead got '.'"); // _nvim/src/nvim/api/private/helpers.h:25:9 +pub const FLOAT_OBJ = @compileError("unable to translate C expr: expected '=' instead got '.'"); // _nvim/src/nvim/api/private/helpers.h:29:9 +pub const STRING_OBJ = @compileError("unable to translate C expr: expected '=' instead got '.'"); // _nvim/src/nvim/api/private/helpers.h:33:9 +pub const BUFFER_OBJ = @compileError("unable to translate C expr: expected '=' instead got '.'"); // _nvim/src/nvim/api/private/helpers.h:39:9 +pub const WINDOW_OBJ = @compileError("unable to translate C expr: expected '=' instead got '.'"); // _nvim/src/nvim/api/private/helpers.h:43:9 +pub const TABPAGE_OBJ = @compileError("unable to translate C expr: expected '=' instead got '.'"); // _nvim/src/nvim/api/private/helpers.h:47:9 +pub const ARRAY_OBJ = @compileError("unable to translate C expr: expected '=' instead got '.'"); // _nvim/src/nvim/api/private/helpers.h:51:9 +pub const DICTIONARY_OBJ = @compileError("unable to translate C expr: expected '=' instead got '.'"); // _nvim/src/nvim/api/private/helpers.h:55:9 +pub const LUAREF_OBJ = @compileError("unable to translate C expr: expected '=' instead got '.'"); // _nvim/src/nvim/api/private/helpers.h:59:9 +pub const PUT_BOOL = @compileError("unable to translate C expr: unexpected token ';'"); // _nvim/src/nvim/api/private/helpers.h:75:9 +pub const MAXSIZE_TEMP_ARRAY = @compileError("unable to translate macro: undefined identifier `__items`"); // _nvim/src/nvim/api/private/helpers.h:83:9 +pub const MAXSIZE_TEMP_DICT = @compileError("unable to translate macro: undefined identifier `__items`"); // _nvim/src/nvim/api/private/helpers.h:89:9 +pub const api_init_string = @compileError("unable to translate C expr: unexpected token '='"); // _nvim/src/nvim/api/private/helpers.h:110:9 +pub const api_init_object = @compileError("unable to translate C expr: unexpected token '='"); // _nvim/src/nvim/api/private/helpers.h:114:9 +pub const api_init_array = @compileError("unable to translate C expr: unexpected token '='"); // _nvim/src/nvim/api/private/helpers.h:115:9 +pub const api_init_dictionary = @compileError("unable to translate C expr: unexpected token '='"); // _nvim/src/nvim/api/private/helpers.h:116:9 +pub const api_free_boolean = @compileError("unable to translate C expr: unexpected token 'Eof'"); // _nvim/src/nvim/api/private/helpers.h:118:9 +pub const api_free_integer = @compileError("unable to translate C expr: unexpected token 'Eof'"); // _nvim/src/nvim/api/private/helpers.h:119:9 +pub const api_free_float = @compileError("unable to translate C expr: unexpected token 'Eof'"); // _nvim/src/nvim/api/private/helpers.h:120:9 +pub const api_free_buffer = @compileError("unable to translate C expr: unexpected token 'Eof'"); // _nvim/src/nvim/api/private/helpers.h:121:9 +pub const api_free_window = @compileError("unable to translate C expr: unexpected token 'Eof'"); // _nvim/src/nvim/api/private/helpers.h:122:9 +pub const api_free_tabpage = @compileError("unable to translate C expr: unexpected token 'Eof'"); // _nvim/src/nvim/api/private/helpers.h:123:9 +pub const TRY_WRAP = @compileError("unable to translate macro: undefined identifier `saved_msg_list`"); // _nvim/src/nvim/api/private/helpers.h:152:9 +pub const TEXTLOCK_WRAP = @compileError("unable to translate macro: undefined identifier `save_cursor`"); // _nvim/src/nvim/api/private/helpers.h:165:9 +pub const FOREACH_ITEM = @compileError("unable to translate macro: undefined identifier `_index`"); // _nvim/src/nvim/api/private/helpers.h:175:9 +pub const WITH_SCRIPT_CONTEXT = @compileError("unable to translate macro: undefined identifier `save_current_sctx`"); // _nvim/src/nvim/api/private/helpers.h:186:9 +pub const RINGBUF_FORALL = @compileError("unable to translate macro: undefined identifier `_length_fa_`"); // ./_nvim/src/nvim/lib/ringbuf.h:42:9 +pub const RINGBUF_ITER_BACK = @compileError("unable to translate macro: undefined identifier `_length_ib_`"); // ./_nvim/src/nvim/lib/ringbuf.h:57:9 +pub const RINGBUF_TYPEDEF = @compileError("unable to translate macro: undefined identifier `buf`"); // ./_nvim/src/nvim/lib/ringbuf.h:69:9 +pub const RINGBUF_DUMMY_FREE = @compileError("unable to translate C expr: unexpected token 'Eof'"); // ./_nvim/src/nvim/lib/ringbuf.h:82:9 +pub const RINGBUF_STATIC = @compileError("unable to translate macro: undefined identifier `_buf`"); // ./_nvim/src/nvim/lib/ringbuf.h:94:9 +pub const RINGBUF_INIT = @compileError("unable to translate macro: undefined identifier `RingBuffer`"); // ./_nvim/src/nvim/lib/ringbuf.h:114:9 +pub const NLUA_CLEAR_REF = @compileError("unable to translate C expr: unexpected token 'do'"); // ./_nvim/src/nvim/lua/executor.h:33:9 +pub const MAP_ARGUMENTS_INIT = @compileError("unable to translate C expr: unexpected token '{'"); // ./_nvim/src/nvim/mapping.h:53:9 +pub const SET_FMARK = @compileError("unable to translate macro: undefined identifier `fmarkp__`"); // _nvim/src/nvim/mark.h:19:9 +pub const RESET_FMARK = @compileError("unable to translate macro: undefined identifier `fmarkp___`"); // _nvim/src/nvim/mark.h:30:9 +pub const SET_XFMARK = @compileError("unable to translate macro: undefined identifier `xfmarkp__`"); // _nvim/src/nvim/mark.h:42:9 +pub const RESET_XFMARK = @compileError("unable to translate macro: undefined identifier `xfmarkp__`"); // _nvim/src/nvim/mark.h:50:9 +pub const MPACK_API = @compileError("unable to translate C expr: unexpected token 'extern'"); // _nvim/src/mpack/mpack_core.h:5:10 +pub const FPURE = @compileError("unable to translate macro: undefined identifier `__attribute__`"); // _nvim/src/mpack/mpack_core.h:14:10 +pub const FNONULL = @compileError("unable to translate macro: undefined identifier `__attribute__`"); // _nvim/src/mpack/mpack_core.h:15:10 +pub const FNONULL_ARG = @compileError("unable to translate macro: undefined identifier `__attribute__`"); // _nvim/src/mpack/mpack_core.h:16:10 +pub const FUNUSED = @compileError("unable to translate macro: undefined identifier `__attribute__`"); // _nvim/src/mpack/mpack_core.h:17:10 +pub const MPACK_TOKBUF_INITIAL_VALUE = @compileError("unable to translate C expr: unexpected token '{'"); // _nvim/src/mpack/mpack_core.h:80:9 +pub const MPACK_THROW = @compileError("unable to translate C expr: unexpected token 'do'"); // _nvim/src/mpack/object.h:13:9 +pub const MPACK_PARSER_STRUCT = @compileError("unable to translate macro: undefined identifier `data`"); // _nvim/src/mpack/object.h:45:9 +pub const TIME_MSG = @compileError("unable to translate C expr: unexpected token 'do'"); // ./_nvim/src/nvim/profile.h:10:9 +pub const WC_KEY_OFF = @compileError("unable to translate macro: undefined identifier `wc_word`"); // ./_nvim/src/nvim/spell_defs.h:249:9 +pub const UGRID_FOREACH_CELL = @compileError("unable to translate macro: undefined identifier `row_cells`"); // ./_nvim/src/nvim/ugrid.h:29:9 +pub const EXPR_OPT_SCOPE_LIST = @compileError("unable to translate C expr: expected ')' instead got '['"); // ./_nvim/src/nvim/viml/parser/expressions.h:85:9 +pub const EXPR_VAR_SCOPE_LIST = @compileError("unable to translate C expr: expected ')' instead got '['"); // ./_nvim/src/nvim/viml/parser/expressions.h:101:9 +pub const __llvm__ = @as(c_int, 1); +pub const __clang__ = @as(c_int, 1); +pub const __clang_major__ = @as(c_int, 16); +pub const __clang_minor__ = @as(c_int, 0); +pub const __clang_patchlevel__ = @as(c_int, 1); +pub const __clang_version__ = "16.0.1 (https://github.com/ziglang/zig-bootstrap 710c5d12660235bc4eac103a8c6677c61f0a9ded)"; +pub const __GNUC__ = @as(c_int, 4); +pub const __GNUC_MINOR__ = @as(c_int, 2); +pub const __GNUC_PATCHLEVEL__ = @as(c_int, 1); +pub const __GXX_ABI_VERSION = @as(c_int, 1002); +pub const __ATOMIC_RELAXED = @as(c_int, 0); +pub const __ATOMIC_CONSUME = @as(c_int, 1); +pub const __ATOMIC_ACQUIRE = @as(c_int, 2); +pub const __ATOMIC_RELEASE = @as(c_int, 3); +pub const __ATOMIC_ACQ_REL = @as(c_int, 4); +pub const __ATOMIC_SEQ_CST = @as(c_int, 5); +pub const __OPENCL_MEMORY_SCOPE_WORK_ITEM = @as(c_int, 0); +pub const __OPENCL_MEMORY_SCOPE_WORK_GROUP = @as(c_int, 1); +pub const __OPENCL_MEMORY_SCOPE_DEVICE = @as(c_int, 2); +pub const __OPENCL_MEMORY_SCOPE_ALL_SVM_DEVICES = @as(c_int, 3); +pub const __OPENCL_MEMORY_SCOPE_SUB_GROUP = @as(c_int, 4); +pub const __PRAGMA_REDEFINE_EXTNAME = @as(c_int, 1); +pub const __VERSION__ = "Clang 16.0.1 (https://github.com/ziglang/zig-bootstrap 710c5d12660235bc4eac103a8c6677c61f0a9ded)"; +pub const __OBJC_BOOL_IS_BOOL = @as(c_int, 0); +pub const __CONSTANT_CFSTRINGS__ = @as(c_int, 1); +pub const __clang_literal_encoding__ = "UTF-8"; +pub const __clang_wide_literal_encoding__ = "UTF-32"; +pub const __ORDER_LITTLE_ENDIAN__ = @as(c_int, 1234); +pub const __ORDER_BIG_ENDIAN__ = @as(c_int, 4321); +pub const __ORDER_PDP_ENDIAN__ = @as(c_int, 3412); +pub const __BYTE_ORDER__ = __ORDER_LITTLE_ENDIAN__; +pub const __LITTLE_ENDIAN__ = @as(c_int, 1); +pub const _LP64 = @as(c_int, 1); +pub const __LP64__ = @as(c_int, 1); +pub const __CHAR_BIT__ = @as(c_int, 8); +pub const __BOOL_WIDTH__ = @as(c_int, 8); +pub const __SHRT_WIDTH__ = @as(c_int, 16); +pub const __INT_WIDTH__ = @as(c_int, 32); +pub const __LONG_WIDTH__ = @as(c_int, 64); +pub const __LLONG_WIDTH__ = @as(c_int, 64); +pub const __BITINT_MAXWIDTH__ = @import("std").zig.c_translation.promoteIntLiteral(c_int, 8388608, .decimal); +pub const __SCHAR_MAX__ = @as(c_int, 127); +pub const __SHRT_MAX__ = @as(c_int, 32767); +pub const __INT_MAX__ = @import("std").zig.c_translation.promoteIntLiteral(c_int, 2147483647, .decimal); +pub const __LONG_MAX__ = @import("std").zig.c_translation.promoteIntLiteral(c_long, 9223372036854775807, .decimal); +pub const __LONG_LONG_MAX__ = @as(c_longlong, 9223372036854775807); +pub const __WCHAR_MAX__ = @import("std").zig.c_translation.promoteIntLiteral(c_int, 2147483647, .decimal); +pub const __WCHAR_WIDTH__ = @as(c_int, 32); +pub const __WINT_MAX__ = @import("std").zig.c_translation.promoteIntLiteral(c_uint, 4294967295, .decimal); +pub const __WINT_WIDTH__ = @as(c_int, 32); +pub const __INTMAX_MAX__ = @import("std").zig.c_translation.promoteIntLiteral(c_long, 9223372036854775807, .decimal); +pub const __INTMAX_WIDTH__ = @as(c_int, 64); +pub const __SIZE_MAX__ = @import("std").zig.c_translation.promoteIntLiteral(c_ulong, 18446744073709551615, .decimal); +pub const __SIZE_WIDTH__ = @as(c_int, 64); +pub const __UINTMAX_MAX__ = @import("std").zig.c_translation.promoteIntLiteral(c_ulong, 18446744073709551615, .decimal); +pub const __UINTMAX_WIDTH__ = @as(c_int, 64); +pub const __PTRDIFF_MAX__ = @import("std").zig.c_translation.promoteIntLiteral(c_long, 9223372036854775807, .decimal); +pub const __PTRDIFF_WIDTH__ = @as(c_int, 64); +pub const __INTPTR_MAX__ = @import("std").zig.c_translation.promoteIntLiteral(c_long, 9223372036854775807, .decimal); +pub const __INTPTR_WIDTH__ = @as(c_int, 64); +pub const __UINTPTR_MAX__ = @import("std").zig.c_translation.promoteIntLiteral(c_ulong, 18446744073709551615, .decimal); +pub const __UINTPTR_WIDTH__ = @as(c_int, 64); +pub const __SIZEOF_DOUBLE__ = @as(c_int, 8); +pub const __SIZEOF_FLOAT__ = @as(c_int, 4); +pub const __SIZEOF_INT__ = @as(c_int, 4); +pub const __SIZEOF_LONG__ = @as(c_int, 8); +pub const __SIZEOF_LONG_DOUBLE__ = @as(c_int, 16); +pub const __SIZEOF_LONG_LONG__ = @as(c_int, 8); +pub const __SIZEOF_POINTER__ = @as(c_int, 8); +pub const __SIZEOF_SHORT__ = @as(c_int, 2); +pub const __SIZEOF_PTRDIFF_T__ = @as(c_int, 8); +pub const __SIZEOF_SIZE_T__ = @as(c_int, 8); +pub const __SIZEOF_WCHAR_T__ = @as(c_int, 4); +pub const __SIZEOF_WINT_T__ = @as(c_int, 4); +pub const __SIZEOF_INT128__ = @as(c_int, 16); +pub const __INTMAX_TYPE__ = c_long; +pub const __INTMAX_FMTd__ = "ld"; +pub const __INTMAX_FMTi__ = "li"; +pub const __UINTMAX_TYPE__ = c_ulong; +pub const __UINTMAX_FMTo__ = "lo"; +pub const __UINTMAX_FMTu__ = "lu"; +pub const __UINTMAX_FMTx__ = "lx"; +pub const __UINTMAX_FMTX__ = "lX"; +pub const __PTRDIFF_TYPE__ = c_long; +pub const __PTRDIFF_FMTd__ = "ld"; +pub const __PTRDIFF_FMTi__ = "li"; +pub const __INTPTR_TYPE__ = c_long; +pub const __INTPTR_FMTd__ = "ld"; +pub const __INTPTR_FMTi__ = "li"; +pub const __SIZE_TYPE__ = c_ulong; +pub const __SIZE_FMTo__ = "lo"; +pub const __SIZE_FMTu__ = "lu"; +pub const __SIZE_FMTx__ = "lx"; +pub const __SIZE_FMTX__ = "lX"; +pub const __WCHAR_TYPE__ = c_int; +pub const __WINT_TYPE__ = c_uint; +pub const __SIG_ATOMIC_MAX__ = @import("std").zig.c_translation.promoteIntLiteral(c_int, 2147483647, .decimal); +pub const __SIG_ATOMIC_WIDTH__ = @as(c_int, 32); +pub const __CHAR16_TYPE__ = c_ushort; +pub const __CHAR32_TYPE__ = c_uint; +pub const __UINTPTR_TYPE__ = c_ulong; +pub const __UINTPTR_FMTo__ = "lo"; +pub const __UINTPTR_FMTu__ = "lu"; +pub const __UINTPTR_FMTx__ = "lx"; +pub const __UINTPTR_FMTX__ = "lX"; +pub const __FLT16_HAS_DENORM__ = @as(c_int, 1); +pub const __FLT16_DIG__ = @as(c_int, 3); +pub const __FLT16_DECIMAL_DIG__ = @as(c_int, 5); +pub const __FLT16_HAS_INFINITY__ = @as(c_int, 1); +pub const __FLT16_HAS_QUIET_NAN__ = @as(c_int, 1); +pub const __FLT16_MANT_DIG__ = @as(c_int, 11); +pub const __FLT16_MAX_10_EXP__ = @as(c_int, 4); +pub const __FLT16_MAX_EXP__ = @as(c_int, 16); +pub const __FLT16_MIN_10_EXP__ = -@as(c_int, 4); +pub const __FLT16_MIN_EXP__ = -@as(c_int, 13); +pub const __FLT_DENORM_MIN__ = @as(f32, 1.40129846e-45); +pub const __FLT_HAS_DENORM__ = @as(c_int, 1); +pub const __FLT_DIG__ = @as(c_int, 6); +pub const __FLT_DECIMAL_DIG__ = @as(c_int, 9); +pub const __FLT_EPSILON__ = @as(f32, 1.19209290e-7); +pub const __FLT_HAS_INFINITY__ = @as(c_int, 1); +pub const __FLT_HAS_QUIET_NAN__ = @as(c_int, 1); +pub const __FLT_MANT_DIG__ = @as(c_int, 24); +pub const __FLT_MAX_10_EXP__ = @as(c_int, 38); +pub const __FLT_MAX_EXP__ = @as(c_int, 128); +pub const __FLT_MAX__ = @as(f32, 3.40282347e+38); +pub const __FLT_MIN_10_EXP__ = -@as(c_int, 37); +pub const __FLT_MIN_EXP__ = -@as(c_int, 125); +pub const __FLT_MIN__ = @as(f32, 1.17549435e-38); +pub const __DBL_DENORM_MIN__ = @as(f64, 4.9406564584124654e-324); +pub const __DBL_HAS_DENORM__ = @as(c_int, 1); +pub const __DBL_DIG__ = @as(c_int, 15); +pub const __DBL_DECIMAL_DIG__ = @as(c_int, 17); +pub const __DBL_EPSILON__ = @as(f64, 2.2204460492503131e-16); +pub const __DBL_HAS_INFINITY__ = @as(c_int, 1); +pub const __DBL_HAS_QUIET_NAN__ = @as(c_int, 1); +pub const __DBL_MANT_DIG__ = @as(c_int, 53); +pub const __DBL_MAX_10_EXP__ = @as(c_int, 308); +pub const __DBL_MAX_EXP__ = @as(c_int, 1024); +pub const __DBL_MAX__ = @as(f64, 1.7976931348623157e+308); +pub const __DBL_MIN_10_EXP__ = -@as(c_int, 307); +pub const __DBL_MIN_EXP__ = -@as(c_int, 1021); +pub const __DBL_MIN__ = @as(f64, 2.2250738585072014e-308); +pub const __LDBL_DENORM_MIN__ = @as(c_longdouble, 3.64519953188247460253e-4951); +pub const __LDBL_HAS_DENORM__ = @as(c_int, 1); +pub const __LDBL_DIG__ = @as(c_int, 18); +pub const __LDBL_DECIMAL_DIG__ = @as(c_int, 21); +pub const __LDBL_EPSILON__ = @as(c_longdouble, 1.08420217248550443401e-19); +pub const __LDBL_HAS_INFINITY__ = @as(c_int, 1); +pub const __LDBL_HAS_QUIET_NAN__ = @as(c_int, 1); +pub const __LDBL_MANT_DIG__ = @as(c_int, 64); +pub const __LDBL_MAX_10_EXP__ = @as(c_int, 4932); +pub const __LDBL_MAX_EXP__ = @as(c_int, 16384); +pub const __LDBL_MAX__ = @as(c_longdouble, 1.18973149535723176502e+4932); +pub const __LDBL_MIN_10_EXP__ = -@as(c_int, 4931); +pub const __LDBL_MIN_EXP__ = -@as(c_int, 16381); +pub const __LDBL_MIN__ = @as(c_longdouble, 3.36210314311209350626e-4932); +pub const __POINTER_WIDTH__ = @as(c_int, 64); +pub const __BIGGEST_ALIGNMENT__ = @as(c_int, 16); +pub const __WINT_UNSIGNED__ = @as(c_int, 1); +pub const __INT8_TYPE__ = i8; +pub const __INT8_FMTd__ = "hhd"; +pub const __INT8_FMTi__ = "hhi"; +pub const __INT8_C_SUFFIX__ = ""; +pub const __INT16_TYPE__ = c_short; +pub const __INT16_FMTd__ = "hd"; +pub const __INT16_FMTi__ = "hi"; +pub const __INT16_C_SUFFIX__ = ""; +pub const __INT32_TYPE__ = c_int; +pub const __INT32_FMTd__ = "d"; +pub const __INT32_FMTi__ = "i"; +pub const __INT32_C_SUFFIX__ = ""; +pub const __INT64_TYPE__ = c_long; +pub const __INT64_FMTd__ = "ld"; +pub const __INT64_FMTi__ = "li"; +pub const __UINT8_TYPE__ = u8; +pub const __UINT8_FMTo__ = "hho"; +pub const __UINT8_FMTu__ = "hhu"; +pub const __UINT8_FMTx__ = "hhx"; +pub const __UINT8_FMTX__ = "hhX"; +pub const __UINT8_C_SUFFIX__ = ""; +pub const __UINT8_MAX__ = @as(c_int, 255); +pub const __INT8_MAX__ = @as(c_int, 127); +pub const __UINT16_TYPE__ = c_ushort; +pub const __UINT16_FMTo__ = "ho"; +pub const __UINT16_FMTu__ = "hu"; +pub const __UINT16_FMTx__ = "hx"; +pub const __UINT16_FMTX__ = "hX"; +pub const __UINT16_C_SUFFIX__ = ""; +pub const __UINT16_MAX__ = @import("std").zig.c_translation.promoteIntLiteral(c_int, 65535, .decimal); +pub const __INT16_MAX__ = @as(c_int, 32767); +pub const __UINT32_TYPE__ = c_uint; +pub const __UINT32_FMTo__ = "o"; +pub const __UINT32_FMTu__ = "u"; +pub const __UINT32_FMTx__ = "x"; +pub const __UINT32_FMTX__ = "X"; +pub const __UINT32_MAX__ = @import("std").zig.c_translation.promoteIntLiteral(c_uint, 4294967295, .decimal); +pub const __INT32_MAX__ = @import("std").zig.c_translation.promoteIntLiteral(c_int, 2147483647, .decimal); +pub const __UINT64_TYPE__ = c_ulong; +pub const __UINT64_FMTo__ = "lo"; +pub const __UINT64_FMTu__ = "lu"; +pub const __UINT64_FMTx__ = "lx"; +pub const __UINT64_FMTX__ = "lX"; +pub const __UINT64_MAX__ = @import("std").zig.c_translation.promoteIntLiteral(c_ulong, 18446744073709551615, .decimal); +pub const __INT64_MAX__ = @import("std").zig.c_translation.promoteIntLiteral(c_long, 9223372036854775807, .decimal); +pub const __INT_LEAST8_TYPE__ = i8; +pub const __INT_LEAST8_MAX__ = @as(c_int, 127); +pub const __INT_LEAST8_WIDTH__ = @as(c_int, 8); +pub const __INT_LEAST8_FMTd__ = "hhd"; +pub const __INT_LEAST8_FMTi__ = "hhi"; +pub const __UINT_LEAST8_TYPE__ = u8; +pub const __UINT_LEAST8_MAX__ = @as(c_int, 255); +pub const __UINT_LEAST8_FMTo__ = "hho"; +pub const __UINT_LEAST8_FMTu__ = "hhu"; +pub const __UINT_LEAST8_FMTx__ = "hhx"; +pub const __UINT_LEAST8_FMTX__ = "hhX"; +pub const __INT_LEAST16_TYPE__ = c_short; +pub const __INT_LEAST16_MAX__ = @as(c_int, 32767); +pub const __INT_LEAST16_WIDTH__ = @as(c_int, 16); +pub const __INT_LEAST16_FMTd__ = "hd"; +pub const __INT_LEAST16_FMTi__ = "hi"; +pub const __UINT_LEAST16_TYPE__ = c_ushort; +pub const __UINT_LEAST16_MAX__ = @import("std").zig.c_translation.promoteIntLiteral(c_int, 65535, .decimal); +pub const __UINT_LEAST16_FMTo__ = "ho"; +pub const __UINT_LEAST16_FMTu__ = "hu"; +pub const __UINT_LEAST16_FMTx__ = "hx"; +pub const __UINT_LEAST16_FMTX__ = "hX"; +pub const __INT_LEAST32_TYPE__ = c_int; +pub const __INT_LEAST32_MAX__ = @import("std").zig.c_translation.promoteIntLiteral(c_int, 2147483647, .decimal); +pub const __INT_LEAST32_WIDTH__ = @as(c_int, 32); +pub const __INT_LEAST32_FMTd__ = "d"; +pub const __INT_LEAST32_FMTi__ = "i"; +pub const __UINT_LEAST32_TYPE__ = c_uint; +pub const __UINT_LEAST32_MAX__ = @import("std").zig.c_translation.promoteIntLiteral(c_uint, 4294967295, .decimal); +pub const __UINT_LEAST32_FMTo__ = "o"; +pub const __UINT_LEAST32_FMTu__ = "u"; +pub const __UINT_LEAST32_FMTx__ = "x"; +pub const __UINT_LEAST32_FMTX__ = "X"; +pub const __INT_LEAST64_TYPE__ = c_long; +pub const __INT_LEAST64_MAX__ = @import("std").zig.c_translation.promoteIntLiteral(c_long, 9223372036854775807, .decimal); +pub const __INT_LEAST64_WIDTH__ = @as(c_int, 64); +pub const __INT_LEAST64_FMTd__ = "ld"; +pub const __INT_LEAST64_FMTi__ = "li"; +pub const __UINT_LEAST64_TYPE__ = c_ulong; +pub const __UINT_LEAST64_MAX__ = @import("std").zig.c_translation.promoteIntLiteral(c_ulong, 18446744073709551615, .decimal); +pub const __UINT_LEAST64_FMTo__ = "lo"; +pub const __UINT_LEAST64_FMTu__ = "lu"; +pub const __UINT_LEAST64_FMTx__ = "lx"; +pub const __UINT_LEAST64_FMTX__ = "lX"; +pub const __INT_FAST8_TYPE__ = i8; +pub const __INT_FAST8_MAX__ = @as(c_int, 127); +pub const __INT_FAST8_WIDTH__ = @as(c_int, 8); +pub const __INT_FAST8_FMTd__ = "hhd"; +pub const __INT_FAST8_FMTi__ = "hhi"; +pub const __UINT_FAST8_TYPE__ = u8; +pub const __UINT_FAST8_MAX__ = @as(c_int, 255); +pub const __UINT_FAST8_FMTo__ = "hho"; +pub const __UINT_FAST8_FMTu__ = "hhu"; +pub const __UINT_FAST8_FMTx__ = "hhx"; +pub const __UINT_FAST8_FMTX__ = "hhX"; +pub const __INT_FAST16_TYPE__ = c_short; +pub const __INT_FAST16_MAX__ = @as(c_int, 32767); +pub const __INT_FAST16_WIDTH__ = @as(c_int, 16); +pub const __INT_FAST16_FMTd__ = "hd"; +pub const __INT_FAST16_FMTi__ = "hi"; +pub const __UINT_FAST16_TYPE__ = c_ushort; +pub const __UINT_FAST16_MAX__ = @import("std").zig.c_translation.promoteIntLiteral(c_int, 65535, .decimal); +pub const __UINT_FAST16_FMTo__ = "ho"; +pub const __UINT_FAST16_FMTu__ = "hu"; +pub const __UINT_FAST16_FMTx__ = "hx"; +pub const __UINT_FAST16_FMTX__ = "hX"; +pub const __INT_FAST32_TYPE__ = c_int; +pub const __INT_FAST32_MAX__ = @import("std").zig.c_translation.promoteIntLiteral(c_int, 2147483647, .decimal); +pub const __INT_FAST32_WIDTH__ = @as(c_int, 32); +pub const __INT_FAST32_FMTd__ = "d"; +pub const __INT_FAST32_FMTi__ = "i"; +pub const __UINT_FAST32_TYPE__ = c_uint; +pub const __UINT_FAST32_MAX__ = @import("std").zig.c_translation.promoteIntLiteral(c_uint, 4294967295, .decimal); +pub const __UINT_FAST32_FMTo__ = "o"; +pub const __UINT_FAST32_FMTu__ = "u"; +pub const __UINT_FAST32_FMTx__ = "x"; +pub const __UINT_FAST32_FMTX__ = "X"; +pub const __INT_FAST64_TYPE__ = c_long; +pub const __INT_FAST64_MAX__ = @import("std").zig.c_translation.promoteIntLiteral(c_long, 9223372036854775807, .decimal); +pub const __INT_FAST64_WIDTH__ = @as(c_int, 64); +pub const __INT_FAST64_FMTd__ = "ld"; +pub const __INT_FAST64_FMTi__ = "li"; +pub const __UINT_FAST64_TYPE__ = c_ulong; +pub const __UINT_FAST64_MAX__ = @import("std").zig.c_translation.promoteIntLiteral(c_ulong, 18446744073709551615, .decimal); +pub const __UINT_FAST64_FMTo__ = "lo"; +pub const __UINT_FAST64_FMTu__ = "lu"; +pub const __UINT_FAST64_FMTx__ = "lx"; +pub const __UINT_FAST64_FMTX__ = "lX"; +pub const __USER_LABEL_PREFIX__ = ""; +pub const __FINITE_MATH_ONLY__ = @as(c_int, 0); +pub const __GNUC_STDC_INLINE__ = @as(c_int, 1); +pub const __GCC_ATOMIC_TEST_AND_SET_TRUEVAL = @as(c_int, 1); +pub const __CLANG_ATOMIC_BOOL_LOCK_FREE = @as(c_int, 2); +pub const __CLANG_ATOMIC_CHAR_LOCK_FREE = @as(c_int, 2); +pub const __CLANG_ATOMIC_CHAR16_T_LOCK_FREE = @as(c_int, 2); +pub const __CLANG_ATOMIC_CHAR32_T_LOCK_FREE = @as(c_int, 2); +pub const __CLANG_ATOMIC_WCHAR_T_LOCK_FREE = @as(c_int, 2); +pub const __CLANG_ATOMIC_SHORT_LOCK_FREE = @as(c_int, 2); +pub const __CLANG_ATOMIC_INT_LOCK_FREE = @as(c_int, 2); +pub const __CLANG_ATOMIC_LONG_LOCK_FREE = @as(c_int, 2); +pub const __CLANG_ATOMIC_LLONG_LOCK_FREE = @as(c_int, 2); +pub const __CLANG_ATOMIC_POINTER_LOCK_FREE = @as(c_int, 2); +pub const __GCC_ATOMIC_BOOL_LOCK_FREE = @as(c_int, 2); +pub const __GCC_ATOMIC_CHAR_LOCK_FREE = @as(c_int, 2); +pub const __GCC_ATOMIC_CHAR16_T_LOCK_FREE = @as(c_int, 2); +pub const __GCC_ATOMIC_CHAR32_T_LOCK_FREE = @as(c_int, 2); +pub const __GCC_ATOMIC_WCHAR_T_LOCK_FREE = @as(c_int, 2); +pub const __GCC_ATOMIC_SHORT_LOCK_FREE = @as(c_int, 2); +pub const __GCC_ATOMIC_INT_LOCK_FREE = @as(c_int, 2); +pub const __GCC_ATOMIC_LONG_LOCK_FREE = @as(c_int, 2); +pub const __GCC_ATOMIC_LLONG_LOCK_FREE = @as(c_int, 2); +pub const __GCC_ATOMIC_POINTER_LOCK_FREE = @as(c_int, 2); +pub const __NO_INLINE__ = @as(c_int, 1); +pub const __PIC__ = @as(c_int, 2); +pub const __pic__ = @as(c_int, 2); +pub const __PIE__ = @as(c_int, 2); +pub const __pie__ = @as(c_int, 2); +pub const __FLT_RADIX__ = @as(c_int, 2); +pub const __DECIMAL_DIG__ = __LDBL_DECIMAL_DIG__; +pub const __GCC_ASM_FLAG_OUTPUTS__ = @as(c_int, 1); +pub const __code_model_small__ = @as(c_int, 1); +pub const __amd64__ = @as(c_int, 1); +pub const __amd64 = @as(c_int, 1); +pub const __x86_64 = @as(c_int, 1); +pub const __x86_64__ = @as(c_int, 1); +pub const __SEG_GS = @as(c_int, 1); +pub const __SEG_FS = @as(c_int, 1); +pub const __corei7 = @as(c_int, 1); +pub const __corei7__ = @as(c_int, 1); +pub const __tune_corei7__ = @as(c_int, 1); +pub const __REGISTER_PREFIX__ = ""; +pub const __NO_MATH_INLINES = @as(c_int, 1); +pub const __AES__ = @as(c_int, 1); +pub const __PCLMUL__ = @as(c_int, 1); +pub const __LAHF_SAHF__ = @as(c_int, 1); +pub const __LZCNT__ = @as(c_int, 1); +pub const __RDRND__ = @as(c_int, 1); +pub const __FSGSBASE__ = @as(c_int, 1); +pub const __BMI__ = @as(c_int, 1); +pub const __BMI2__ = @as(c_int, 1); +pub const __POPCNT__ = @as(c_int, 1); +pub const __PRFCHW__ = @as(c_int, 1); +pub const __RDSEED__ = @as(c_int, 1); +pub const __ADX__ = @as(c_int, 1); +pub const __MOVBE__ = @as(c_int, 1); +pub const __FMA__ = @as(c_int, 1); +pub const __F16C__ = @as(c_int, 1); +pub const __FXSR__ = @as(c_int, 1); +pub const __XSAVE__ = @as(c_int, 1); +pub const __XSAVEOPT__ = @as(c_int, 1); +pub const __XSAVEC__ = @as(c_int, 1); +pub const __XSAVES__ = @as(c_int, 1); +pub const __CLFLUSHOPT__ = @as(c_int, 1); +pub const __INVPCID__ = @as(c_int, 1); +pub const __CRC32__ = @as(c_int, 1); +pub const __AVX2__ = @as(c_int, 1); +pub const __AVX__ = @as(c_int, 1); +pub const __SSE4_2__ = @as(c_int, 1); +pub const __SSE4_1__ = @as(c_int, 1); +pub const __SSSE3__ = @as(c_int, 1); +pub const __SSE3__ = @as(c_int, 1); +pub const __SSE2__ = @as(c_int, 1); +pub const __SSE2_MATH__ = @as(c_int, 1); +pub const __SSE__ = @as(c_int, 1); +pub const __SSE_MATH__ = @as(c_int, 1); +pub const __MMX__ = @as(c_int, 1); +pub const __GCC_HAVE_SYNC_COMPARE_AND_SWAP_1 = @as(c_int, 1); +pub const __GCC_HAVE_SYNC_COMPARE_AND_SWAP_2 = @as(c_int, 1); +pub const __GCC_HAVE_SYNC_COMPARE_AND_SWAP_4 = @as(c_int, 1); +pub const __GCC_HAVE_SYNC_COMPARE_AND_SWAP_8 = @as(c_int, 1); +pub const __GCC_HAVE_SYNC_COMPARE_AND_SWAP_16 = @as(c_int, 1); +pub const __SIZEOF_FLOAT128__ = @as(c_int, 16); +pub const unix = @as(c_int, 1); +pub const __unix = @as(c_int, 1); +pub const __unix__ = @as(c_int, 1); +pub const linux = @as(c_int, 1); +pub const __linux = @as(c_int, 1); +pub const __linux__ = @as(c_int, 1); +pub const __ELF__ = @as(c_int, 1); +pub const __gnu_linux__ = @as(c_int, 1); +pub const __FLOAT128__ = @as(c_int, 1); +pub const __STDC__ = @as(c_int, 1); +pub const __STDC_HOSTED__ = @as(c_int, 1); +pub const __STDC_VERSION__ = @as(c_long, 201710); +pub const __STDC_UTF_16__ = @as(c_int, 1); +pub const __STDC_UTF_32__ = @as(c_int, 1); +pub const _DEBUG = @as(c_int, 1); +pub const INCLUDE_GENERATED_DECLARATIONS = @as(c_int, 1); +pub const __GCC_HAVE_DWARF2_CFI_ASM = @as(c_int, 1); +pub const NVIM_API_AUTOCMD_H = ""; +pub const __CLANG_STDINT_H = ""; +pub const _STDINT_H = @as(c_int, 1); +pub const __GLIBC_INTERNAL_STARTING_HEADER_IMPLEMENTATION = ""; +pub const _FEATURES_H = @as(c_int, 1); +pub const __KERNEL_STRICT_NAMES = ""; +pub inline fn __GNUC_PREREQ(maj: anytype, min: anytype) @TypeOf(((__GNUC__ << @as(c_int, 16)) + __GNUC_MINOR__) >= ((maj << @as(c_int, 16)) + min)) { + return ((__GNUC__ << @as(c_int, 16)) + __GNUC_MINOR__) >= ((maj << @as(c_int, 16)) + min); +} +pub inline fn __glibc_clang_prereq(maj: anytype, min: anytype) @TypeOf(((__clang_major__ << @as(c_int, 16)) + __clang_minor__) >= ((maj << @as(c_int, 16)) + min)) { + return ((__clang_major__ << @as(c_int, 16)) + __clang_minor__) >= ((maj << @as(c_int, 16)) + min); +} +pub const _DEFAULT_SOURCE = @as(c_int, 1); +pub const __GLIBC_USE_ISOC2X = @as(c_int, 0); +pub const __USE_ISOC11 = @as(c_int, 1); +pub const __USE_ISOC99 = @as(c_int, 1); +pub const __USE_ISOC95 = @as(c_int, 1); +pub const __USE_POSIX_IMPLICITLY = @as(c_int, 1); +pub const _POSIX_SOURCE = @as(c_int, 1); +pub const _POSIX_C_SOURCE = @as(c_long, 200809); +pub const __USE_POSIX = @as(c_int, 1); +pub const __USE_POSIX2 = @as(c_int, 1); +pub const __USE_POSIX199309 = @as(c_int, 1); +pub const __USE_POSIX199506 = @as(c_int, 1); +pub const __USE_XOPEN2K = @as(c_int, 1); +pub const __USE_XOPEN2K8 = @as(c_int, 1); +pub const _ATFILE_SOURCE = @as(c_int, 1); +pub const __WORDSIZE = @as(c_int, 64); +pub const __WORDSIZE_TIME64_COMPAT32 = @as(c_int, 1); +pub const __SYSCALL_WORDSIZE = @as(c_int, 64); +pub const __TIMESIZE = __WORDSIZE; +pub const __USE_MISC = @as(c_int, 1); +pub const __USE_ATFILE = @as(c_int, 1); +pub const __USE_FORTIFY_LEVEL = @as(c_int, 0); +pub const __GLIBC_USE_DEPRECATED_GETS = @as(c_int, 0); +pub const __GLIBC_USE_DEPRECATED_SCANF = @as(c_int, 0); +pub const _STDC_PREDEF_H = @as(c_int, 1); +pub const __STDC_IEC_559__ = @as(c_int, 1); +pub const __STDC_IEC_60559_BFP__ = @as(c_long, 201404); +pub const __STDC_IEC_559_COMPLEX__ = @as(c_int, 1); +pub const __STDC_IEC_60559_COMPLEX__ = @as(c_long, 201404); +pub const __STDC_ISO_10646__ = @as(c_long, 201706); +pub const __GNU_LIBRARY__ = @as(c_int, 6); +pub const __GLIBC__ = @as(c_int, 2); +pub const __GLIBC_MINOR__ = @as(c_int, 37); +pub inline fn __GLIBC_PREREQ(maj: anytype, min: anytype) @TypeOf(((__GLIBC__ << @as(c_int, 16)) + __GLIBC_MINOR__) >= ((maj << @as(c_int, 16)) + min)) { + return ((__GLIBC__ << @as(c_int, 16)) + __GLIBC_MINOR__) >= ((maj << @as(c_int, 16)) + min); +} +pub const _SYS_CDEFS_H = @as(c_int, 1); +pub inline fn __glibc_has_builtin(name: anytype) @TypeOf(__has_builtin(name)) { + return __has_builtin(name); +} +pub const __LEAF = ""; +pub const __LEAF_ATTR = ""; +pub inline fn __P(args: anytype) @TypeOf(args) { + return args; +} +pub inline fn __PMT(args: anytype) @TypeOf(args) { + return args; +} +pub const __ptr_t = ?*anyopaque; +pub const __BEGIN_DECLS = ""; +pub const __END_DECLS = ""; +pub inline fn __bos(ptr: anytype) @TypeOf(__builtin_object_size(ptr, __USE_FORTIFY_LEVEL > @as(c_int, 1))) { + return __builtin_object_size(ptr, __USE_FORTIFY_LEVEL > @as(c_int, 1)); +} +pub inline fn __bos0(ptr: anytype) @TypeOf(__builtin_object_size(ptr, @as(c_int, 0))) { + return __builtin_object_size(ptr, @as(c_int, 0)); +} +pub inline fn __glibc_objsize0(__o: anytype) @TypeOf(__bos0(__o)) { + return __bos0(__o); +} +pub inline fn __glibc_objsize(__o: anytype) @TypeOf(__bos(__o)) { + return __bos(__o); +} +pub inline fn __glibc_safe_len_cond(__l: anytype, __s: anytype, __osz: anytype) @TypeOf(__l <= @import("std").zig.c_translation.MacroArithmetic.div(__osz, __s)) { + return __l <= @import("std").zig.c_translation.MacroArithmetic.div(__osz, __s); +} +pub inline fn __glibc_safe_or_unknown_len(__l: anytype, __s: anytype, __osz: anytype) @TypeOf(((__builtin_constant_p(__osz) != 0) and (__osz == (__SIZE_TYPE__ - @as(c_int, 1)))) or (((__glibc_unsigned_or_positive(__l) != 0) and (__builtin_constant_p(__glibc_safe_len_cond(__SIZE_TYPE__(__l), __s, __osz)) != 0)) and (__glibc_safe_len_cond(__SIZE_TYPE__(__l), __s, __osz) != 0))) { + return ((__builtin_constant_p(__osz) != 0) and (__osz == (__SIZE_TYPE__ - @as(c_int, 1)))) or (((__glibc_unsigned_or_positive(__l) != 0) and (__builtin_constant_p(__glibc_safe_len_cond(__SIZE_TYPE__(__l), __s, __osz)) != 0)) and (__glibc_safe_len_cond(__SIZE_TYPE__(__l), __s, __osz) != 0)); +} +pub inline fn __glibc_unsafe_len(__l: anytype, __s: anytype, __osz: anytype) @TypeOf(((__glibc_unsigned_or_positive(__l) != 0) and (__builtin_constant_p(__glibc_safe_len_cond(__SIZE_TYPE__(__l), __s, __osz)) != 0)) and !(__glibc_safe_len_cond(__SIZE_TYPE__(__l), __s, __osz) != 0)) { + return ((__glibc_unsigned_or_positive(__l) != 0) and (__builtin_constant_p(__glibc_safe_len_cond(__SIZE_TYPE__(__l), __s, __osz)) != 0)) and !(__glibc_safe_len_cond(__SIZE_TYPE__(__l), __s, __osz) != 0); +} +pub const __glibc_c99_flexarr_available = @as(c_int, 1); +pub inline fn __ASMNAME(cname: anytype) @TypeOf(__ASMNAME2(__USER_LABEL_PREFIX__, cname)) { + return __ASMNAME2(__USER_LABEL_PREFIX__, cname); +} +pub inline fn __nonnull(params: anytype) @TypeOf(__attribute_nonnull__(params)) { + return __attribute_nonnull__(params); +} +pub const __wur = ""; +pub const __fortify_function = __extern_always_inline ++ __attribute_artificial__; +pub inline fn __glibc_unlikely(cond: anytype) @TypeOf(__builtin_expect(cond, @as(c_int, 0))) { + return __builtin_expect(cond, @as(c_int, 0)); +} +pub inline fn __glibc_likely(cond: anytype) @TypeOf(__builtin_expect(cond, @as(c_int, 1))) { + return __builtin_expect(cond, @as(c_int, 1)); +} +pub const __attribute_nonstring__ = ""; +pub const __LDOUBLE_REDIRECTS_TO_FLOAT128_ABI = @as(c_int, 0); +pub inline fn __LDBL_REDIR1(name: anytype, proto: anytype, alias: anytype) @TypeOf(name ++ proto) { + _ = @TypeOf(alias); + return name ++ proto; +} +pub inline fn __LDBL_REDIR(name: anytype, proto: anytype) @TypeOf(name ++ proto) { + return name ++ proto; +} +pub inline fn __LDBL_REDIR1_NTH(name: anytype, proto: anytype, alias: anytype) @TypeOf(name ++ proto ++ __THROW) { + _ = @TypeOf(alias); + return name ++ proto ++ __THROW; +} +pub inline fn __LDBL_REDIR_NTH(name: anytype, proto: anytype) @TypeOf(name ++ proto ++ __THROW) { + return name ++ proto ++ __THROW; +} +pub inline fn __REDIRECT_LDBL(name: anytype, proto: anytype, alias: anytype) @TypeOf(__REDIRECT(name, proto, alias)) { + return __REDIRECT(name, proto, alias); +} +pub inline fn __REDIRECT_NTH_LDBL(name: anytype, proto: anytype, alias: anytype) @TypeOf(__REDIRECT_NTH(name, proto, alias)) { + return __REDIRECT_NTH(name, proto, alias); +} +pub const __HAVE_GENERIC_SELECTION = @as(c_int, 1); +pub const __attr_dealloc_free = ""; +pub const __stub___compat_bdflush = ""; +pub const __stub_chflags = ""; +pub const __stub_fchflags = ""; +pub const __stub_gtty = ""; +pub const __stub_revoke = ""; +pub const __stub_setlogin = ""; +pub const __stub_sigreturn = ""; +pub const __stub_stty = ""; +pub const __GLIBC_USE_LIB_EXT2 = @as(c_int, 0); +pub const __GLIBC_USE_IEC_60559_BFP_EXT = @as(c_int, 0); +pub const __GLIBC_USE_IEC_60559_BFP_EXT_C2X = @as(c_int, 0); +pub const __GLIBC_USE_IEC_60559_EXT = @as(c_int, 0); +pub const __GLIBC_USE_IEC_60559_FUNCS_EXT = @as(c_int, 0); +pub const __GLIBC_USE_IEC_60559_FUNCS_EXT_C2X = @as(c_int, 0); +pub const __GLIBC_USE_IEC_60559_TYPES_EXT = @as(c_int, 0); +pub const _BITS_TYPES_H = @as(c_int, 1); +pub const __S16_TYPE = c_short; +pub const __U16_TYPE = c_ushort; +pub const __S32_TYPE = c_int; +pub const __U32_TYPE = c_uint; +pub const __SLONGWORD_TYPE = c_long; +pub const __ULONGWORD_TYPE = c_ulong; +pub const __SQUAD_TYPE = c_long; +pub const __UQUAD_TYPE = c_ulong; +pub const __SWORD_TYPE = c_long; +pub const __UWORD_TYPE = c_ulong; +pub const __SLONG32_TYPE = c_int; +pub const __ULONG32_TYPE = c_uint; +pub const __S64_TYPE = c_long; +pub const __U64_TYPE = c_ulong; +pub const _BITS_TYPESIZES_H = @as(c_int, 1); +pub const __SYSCALL_SLONG_TYPE = __SLONGWORD_TYPE; +pub const __SYSCALL_ULONG_TYPE = __ULONGWORD_TYPE; +pub const __DEV_T_TYPE = __UQUAD_TYPE; +pub const __UID_T_TYPE = __U32_TYPE; +pub const __GID_T_TYPE = __U32_TYPE; +pub const __INO_T_TYPE = __SYSCALL_ULONG_TYPE; +pub const __INO64_T_TYPE = __UQUAD_TYPE; +pub const __MODE_T_TYPE = __U32_TYPE; +pub const __NLINK_T_TYPE = __SYSCALL_ULONG_TYPE; +pub const __FSWORD_T_TYPE = __SYSCALL_SLONG_TYPE; +pub const __OFF_T_TYPE = __SYSCALL_SLONG_TYPE; +pub const __OFF64_T_TYPE = __SQUAD_TYPE; +pub const __PID_T_TYPE = __S32_TYPE; +pub const __RLIM_T_TYPE = __SYSCALL_ULONG_TYPE; +pub const __RLIM64_T_TYPE = __UQUAD_TYPE; +pub const __BLKCNT_T_TYPE = __SYSCALL_SLONG_TYPE; +pub const __BLKCNT64_T_TYPE = __SQUAD_TYPE; +pub const __FSBLKCNT_T_TYPE = __SYSCALL_ULONG_TYPE; +pub const __FSBLKCNT64_T_TYPE = __UQUAD_TYPE; +pub const __FSFILCNT_T_TYPE = __SYSCALL_ULONG_TYPE; +pub const __FSFILCNT64_T_TYPE = __UQUAD_TYPE; +pub const __ID_T_TYPE = __U32_TYPE; +pub const __CLOCK_T_TYPE = __SYSCALL_SLONG_TYPE; +pub const __TIME_T_TYPE = __SYSCALL_SLONG_TYPE; +pub const __USECONDS_T_TYPE = __U32_TYPE; +pub const __SUSECONDS_T_TYPE = __SYSCALL_SLONG_TYPE; +pub const __SUSECONDS64_T_TYPE = __SQUAD_TYPE; +pub const __DADDR_T_TYPE = __S32_TYPE; +pub const __KEY_T_TYPE = __S32_TYPE; +pub const __CLOCKID_T_TYPE = __S32_TYPE; +pub const __TIMER_T_TYPE = ?*anyopaque; +pub const __BLKSIZE_T_TYPE = __SYSCALL_SLONG_TYPE; +pub const __SSIZE_T_TYPE = __SWORD_TYPE; +pub const __CPU_MASK_TYPE = __SYSCALL_ULONG_TYPE; +pub const __OFF_T_MATCHES_OFF64_T = @as(c_int, 1); +pub const __INO_T_MATCHES_INO64_T = @as(c_int, 1); +pub const __RLIM_T_MATCHES_RLIM64_T = @as(c_int, 1); +pub const __STATFS_MATCHES_STATFS64 = @as(c_int, 1); +pub const __KERNEL_OLD_TIMEVAL_MATCHES_TIMEVAL64 = @as(c_int, 1); +pub const __FD_SETSIZE = @as(c_int, 1024); +pub const _BITS_TIME64_H = @as(c_int, 1); +pub const __TIME64_T_TYPE = __TIME_T_TYPE; +pub const _BITS_WCHAR_H = @as(c_int, 1); +pub const __WCHAR_MAX = __WCHAR_MAX__; +pub const __WCHAR_MIN = -__WCHAR_MAX - @as(c_int, 1); +pub const _BITS_STDINT_INTN_H = @as(c_int, 1); +pub const _BITS_STDINT_UINTN_H = @as(c_int, 1); +pub const __intptr_t_defined = ""; +pub const __INT64_C = @import("std").zig.c_translation.Macros.L_SUFFIX; +pub const __UINT64_C = @import("std").zig.c_translation.Macros.UL_SUFFIX; +pub const INT8_MIN = -@as(c_int, 128); +pub const INT16_MIN = -@as(c_int, 32767) - @as(c_int, 1); +pub const INT32_MIN = -@import("std").zig.c_translation.promoteIntLiteral(c_int, 2147483647, .decimal) - @as(c_int, 1); +pub const INT64_MIN = -__INT64_C(@import("std").zig.c_translation.promoteIntLiteral(c_int, 9223372036854775807, .decimal)) - @as(c_int, 1); +pub const INT8_MAX = @as(c_int, 127); +pub const INT16_MAX = @as(c_int, 32767); +pub const INT32_MAX = @import("std").zig.c_translation.promoteIntLiteral(c_int, 2147483647, .decimal); +pub const INT64_MAX = __INT64_C(@import("std").zig.c_translation.promoteIntLiteral(c_int, 9223372036854775807, .decimal)); +pub const UINT8_MAX = @as(c_int, 255); +pub const UINT16_MAX = @import("std").zig.c_translation.promoteIntLiteral(c_int, 65535, .decimal); +pub const UINT32_MAX = @import("std").zig.c_translation.promoteIntLiteral(c_uint, 4294967295, .decimal); +pub const UINT64_MAX = __UINT64_C(@import("std").zig.c_translation.promoteIntLiteral(c_int, 18446744073709551615, .decimal)); +pub const INT_LEAST8_MIN = -@as(c_int, 128); +pub const INT_LEAST16_MIN = -@as(c_int, 32767) - @as(c_int, 1); +pub const INT_LEAST32_MIN = -@import("std").zig.c_translation.promoteIntLiteral(c_int, 2147483647, .decimal) - @as(c_int, 1); +pub const INT_LEAST64_MIN = -__INT64_C(@import("std").zig.c_translation.promoteIntLiteral(c_int, 9223372036854775807, .decimal)) - @as(c_int, 1); +pub const INT_LEAST8_MAX = @as(c_int, 127); +pub const INT_LEAST16_MAX = @as(c_int, 32767); +pub const INT_LEAST32_MAX = @import("std").zig.c_translation.promoteIntLiteral(c_int, 2147483647, .decimal); +pub const INT_LEAST64_MAX = __INT64_C(@import("std").zig.c_translation.promoteIntLiteral(c_int, 9223372036854775807, .decimal)); +pub const UINT_LEAST8_MAX = @as(c_int, 255); +pub const UINT_LEAST16_MAX = @import("std").zig.c_translation.promoteIntLiteral(c_int, 65535, .decimal); +pub const UINT_LEAST32_MAX = @import("std").zig.c_translation.promoteIntLiteral(c_uint, 4294967295, .decimal); +pub const UINT_LEAST64_MAX = __UINT64_C(@import("std").zig.c_translation.promoteIntLiteral(c_int, 18446744073709551615, .decimal)); +pub const INT_FAST8_MIN = -@as(c_int, 128); +pub const INT_FAST16_MIN = -@import("std").zig.c_translation.promoteIntLiteral(c_long, 9223372036854775807, .decimal) - @as(c_int, 1); +pub const INT_FAST32_MIN = -@import("std").zig.c_translation.promoteIntLiteral(c_long, 9223372036854775807, .decimal) - @as(c_int, 1); +pub const INT_FAST64_MIN = -__INT64_C(@import("std").zig.c_translation.promoteIntLiteral(c_int, 9223372036854775807, .decimal)) - @as(c_int, 1); +pub const INT_FAST8_MAX = @as(c_int, 127); +pub const INT_FAST16_MAX = @import("std").zig.c_translation.promoteIntLiteral(c_long, 9223372036854775807, .decimal); +pub const INT_FAST32_MAX = @import("std").zig.c_translation.promoteIntLiteral(c_long, 9223372036854775807, .decimal); +pub const INT_FAST64_MAX = __INT64_C(@import("std").zig.c_translation.promoteIntLiteral(c_int, 9223372036854775807, .decimal)); +pub const UINT_FAST8_MAX = @as(c_int, 255); +pub const UINT_FAST16_MAX = @import("std").zig.c_translation.promoteIntLiteral(c_ulong, 18446744073709551615, .decimal); +pub const UINT_FAST32_MAX = @import("std").zig.c_translation.promoteIntLiteral(c_ulong, 18446744073709551615, .decimal); +pub const UINT_FAST64_MAX = __UINT64_C(@import("std").zig.c_translation.promoteIntLiteral(c_int, 18446744073709551615, .decimal)); +pub const INTPTR_MIN = -@import("std").zig.c_translation.promoteIntLiteral(c_long, 9223372036854775807, .decimal) - @as(c_int, 1); +pub const INTPTR_MAX = @import("std").zig.c_translation.promoteIntLiteral(c_long, 9223372036854775807, .decimal); +pub const UINTPTR_MAX = @import("std").zig.c_translation.promoteIntLiteral(c_ulong, 18446744073709551615, .decimal); +pub const INTMAX_MIN = -__INT64_C(@import("std").zig.c_translation.promoteIntLiteral(c_int, 9223372036854775807, .decimal)) - @as(c_int, 1); +pub const INTMAX_MAX = __INT64_C(@import("std").zig.c_translation.promoteIntLiteral(c_int, 9223372036854775807, .decimal)); +pub const UINTMAX_MAX = __UINT64_C(@import("std").zig.c_translation.promoteIntLiteral(c_int, 18446744073709551615, .decimal)); +pub const PTRDIFF_MIN = -@import("std").zig.c_translation.promoteIntLiteral(c_long, 9223372036854775807, .decimal) - @as(c_int, 1); +pub const PTRDIFF_MAX = @import("std").zig.c_translation.promoteIntLiteral(c_long, 9223372036854775807, .decimal); +pub const SIG_ATOMIC_MIN = -@import("std").zig.c_translation.promoteIntLiteral(c_int, 2147483647, .decimal) - @as(c_int, 1); +pub const SIG_ATOMIC_MAX = @import("std").zig.c_translation.promoteIntLiteral(c_int, 2147483647, .decimal); +pub const SIZE_MAX = @import("std").zig.c_translation.promoteIntLiteral(c_ulong, 18446744073709551615, .decimal); +pub const WCHAR_MIN = __WCHAR_MIN; +pub const WCHAR_MAX = __WCHAR_MAX; +pub const WINT_MIN = @as(c_uint, 0); +pub const WINT_MAX = @import("std").zig.c_translation.promoteIntLiteral(c_uint, 4294967295, .decimal); +pub inline fn INT8_C(c: anytype) @TypeOf(c) { + return c; +} +pub inline fn INT16_C(c: anytype) @TypeOf(c) { + return c; +} +pub inline fn INT32_C(c: anytype) @TypeOf(c) { + return c; +} +pub const INT64_C = @import("std").zig.c_translation.Macros.L_SUFFIX; +pub inline fn UINT8_C(c: anytype) @TypeOf(c) { + return c; +} +pub inline fn UINT16_C(c: anytype) @TypeOf(c) { + return c; +} +pub const UINT32_C = @import("std").zig.c_translation.Macros.U_SUFFIX; +pub const UINT64_C = @import("std").zig.c_translation.Macros.UL_SUFFIX; +pub const INTMAX_C = @import("std").zig.c_translation.Macros.L_SUFFIX; +pub const UINTMAX_C = @import("std").zig.c_translation.Macros.UL_SUFFIX; +pub const NVIM_API_KEYSETS_H = ""; +pub const NVIM_API_PRIVATE_DEFS_H = ""; +pub const __STDBOOL_H = ""; +pub const __bool_true_false_are_defined = @as(c_int, 1); +pub const @"bool" = bool; +pub const @"true" = @as(c_int, 1); +pub const @"false" = @as(c_int, 0); +pub const _STRING_H = @as(c_int, 1); +pub const __need_size_t = ""; +pub const __need_NULL = ""; +pub const _SIZE_T = ""; +pub const NULL = @import("std").zig.c_translation.cast(?*anyopaque, @as(c_int, 0)); +pub const _BITS_TYPES_LOCALE_T_H = @as(c_int, 1); +pub const _BITS_TYPES___LOCALE_T_H = @as(c_int, 1); +pub const _STRINGS_H = @as(c_int, 1); +pub const NVIM_LIB_KVEC_H = ""; +pub const __need_wchar_t = ""; +pub const _WCHAR_T = ""; +pub const _STDLIB_H = @as(c_int, 1); +pub const WNOHANG = @as(c_int, 1); +pub const WUNTRACED = @as(c_int, 2); +pub const WSTOPPED = @as(c_int, 2); +pub const WEXITED = @as(c_int, 4); +pub const WCONTINUED = @as(c_int, 8); +pub const WNOWAIT = @import("std").zig.c_translation.promoteIntLiteral(c_int, 0x01000000, .hexadecimal); +pub const __WNOTHREAD = @import("std").zig.c_translation.promoteIntLiteral(c_int, 0x20000000, .hexadecimal); +pub const __WALL = @import("std").zig.c_translation.promoteIntLiteral(c_int, 0x40000000, .hexadecimal); +pub const __WCLONE = @import("std").zig.c_translation.promoteIntLiteral(c_int, 0x80000000, .hexadecimal); +pub inline fn __WEXITSTATUS(status: anytype) @TypeOf((status & @import("std").zig.c_translation.promoteIntLiteral(c_int, 0xff00, .hexadecimal)) >> @as(c_int, 8)) { + return (status & @import("std").zig.c_translation.promoteIntLiteral(c_int, 0xff00, .hexadecimal)) >> @as(c_int, 8); +} +pub inline fn __WTERMSIG(status: anytype) @TypeOf(status & @as(c_int, 0x7f)) { + return status & @as(c_int, 0x7f); +} +pub inline fn __WSTOPSIG(status: anytype) @TypeOf(__WEXITSTATUS(status)) { + return __WEXITSTATUS(status); +} +pub inline fn __WIFEXITED(status: anytype) @TypeOf(__WTERMSIG(status) == @as(c_int, 0)) { + return __WTERMSIG(status) == @as(c_int, 0); +} +pub inline fn __WIFSIGNALED(status: anytype) @TypeOf((@import("std").zig.c_translation.cast(i8, (status & @as(c_int, 0x7f)) + @as(c_int, 1)) >> @as(c_int, 1)) > @as(c_int, 0)) { + return (@import("std").zig.c_translation.cast(i8, (status & @as(c_int, 0x7f)) + @as(c_int, 1)) >> @as(c_int, 1)) > @as(c_int, 0); +} +pub inline fn __WIFSTOPPED(status: anytype) @TypeOf((status & @as(c_int, 0xff)) == @as(c_int, 0x7f)) { + return (status & @as(c_int, 0xff)) == @as(c_int, 0x7f); +} +pub inline fn __WIFCONTINUED(status: anytype) @TypeOf(status == __W_CONTINUED) { + return status == __W_CONTINUED; +} +pub inline fn __WCOREDUMP(status: anytype) @TypeOf(status & __WCOREFLAG) { + return status & __WCOREFLAG; +} +pub inline fn __W_EXITCODE(ret: anytype, sig: anytype) @TypeOf((ret << @as(c_int, 8)) | sig) { + return (ret << @as(c_int, 8)) | sig; +} +pub inline fn __W_STOPCODE(sig: anytype) @TypeOf((sig << @as(c_int, 8)) | @as(c_int, 0x7f)) { + return (sig << @as(c_int, 8)) | @as(c_int, 0x7f); +} +pub const __W_CONTINUED = @import("std").zig.c_translation.promoteIntLiteral(c_int, 0xffff, .hexadecimal); +pub const __WCOREFLAG = @as(c_int, 0x80); +pub inline fn WEXITSTATUS(status: anytype) @TypeOf(__WEXITSTATUS(status)) { + return __WEXITSTATUS(status); +} +pub inline fn WTERMSIG(status: anytype) @TypeOf(__WTERMSIG(status)) { + return __WTERMSIG(status); +} +pub inline fn WSTOPSIG(status: anytype) @TypeOf(__WSTOPSIG(status)) { + return __WSTOPSIG(status); +} +pub inline fn WIFEXITED(status: anytype) @TypeOf(__WIFEXITED(status)) { + return __WIFEXITED(status); +} +pub inline fn WIFSIGNALED(status: anytype) @TypeOf(__WIFSIGNALED(status)) { + return __WIFSIGNALED(status); +} +pub inline fn WIFSTOPPED(status: anytype) @TypeOf(__WIFSTOPPED(status)) { + return __WIFSTOPPED(status); +} +pub inline fn WIFCONTINUED(status: anytype) @TypeOf(__WIFCONTINUED(status)) { + return __WIFCONTINUED(status); +} +pub const _BITS_FLOATN_H = ""; +pub const __HAVE_FLOAT128 = @as(c_int, 0); +pub const __HAVE_DISTINCT_FLOAT128 = @as(c_int, 0); +pub const __HAVE_FLOAT64X = @as(c_int, 1); +pub const __HAVE_FLOAT64X_LONG_DOUBLE = @as(c_int, 1); +pub const _BITS_FLOATN_COMMON_H = ""; +pub const __HAVE_FLOAT16 = @as(c_int, 0); +pub const __HAVE_FLOAT32 = @as(c_int, 1); +pub const __HAVE_FLOAT64 = @as(c_int, 1); +pub const __HAVE_FLOAT32X = @as(c_int, 1); +pub const __HAVE_FLOAT128X = @as(c_int, 0); +pub const __HAVE_DISTINCT_FLOAT16 = __HAVE_FLOAT16; +pub const __HAVE_DISTINCT_FLOAT32 = @as(c_int, 0); +pub const __HAVE_DISTINCT_FLOAT64 = @as(c_int, 0); +pub const __HAVE_DISTINCT_FLOAT32X = @as(c_int, 0); +pub const __HAVE_DISTINCT_FLOAT64X = @as(c_int, 0); +pub const __HAVE_DISTINCT_FLOAT128X = __HAVE_FLOAT128X; +pub const __HAVE_FLOAT128_UNLIKE_LDBL = (__HAVE_DISTINCT_FLOAT128 != 0) and (__LDBL_MANT_DIG__ != @as(c_int, 113)); +pub const __HAVE_FLOATN_NOT_TYPEDEF = @as(c_int, 0); +pub const __f32 = @import("std").zig.c_translation.Macros.F_SUFFIX; +pub inline fn __f64(x: anytype) @TypeOf(x) { + return x; +} +pub inline fn __f32x(x: anytype) @TypeOf(x) { + return x; +} +pub const __f64x = @import("std").zig.c_translation.Macros.L_SUFFIX; +pub inline fn __builtin_huge_valf32() @TypeOf(__builtin_huge_valf()) { + return __builtin_huge_valf(); +} +pub inline fn __builtin_inff32() @TypeOf(__builtin_inff()) { + return __builtin_inff(); +} +pub inline fn __builtin_nanf32(x: anytype) @TypeOf(__builtin_nanf(x)) { + return __builtin_nanf(x); +} +pub const __ldiv_t_defined = @as(c_int, 1); +pub const __lldiv_t_defined = @as(c_int, 1); +pub const RAND_MAX = @import("std").zig.c_translation.promoteIntLiteral(c_int, 2147483647, .decimal); +pub const EXIT_FAILURE = @as(c_int, 1); +pub const EXIT_SUCCESS = @as(c_int, 0); +pub const MB_CUR_MAX = __ctype_get_mb_cur_max(); +pub const _SYS_TYPES_H = @as(c_int, 1); +pub const __u_char_defined = ""; +pub const __ino_t_defined = ""; +pub const __dev_t_defined = ""; +pub const __gid_t_defined = ""; +pub const __mode_t_defined = ""; +pub const __nlink_t_defined = ""; +pub const __uid_t_defined = ""; +pub const __off_t_defined = ""; +pub const __pid_t_defined = ""; +pub const __id_t_defined = ""; +pub const __ssize_t_defined = ""; +pub const __daddr_t_defined = ""; +pub const __key_t_defined = ""; +pub const __clock_t_defined = @as(c_int, 1); +pub const __clockid_t_defined = @as(c_int, 1); +pub const __time_t_defined = @as(c_int, 1); +pub const __timer_t_defined = @as(c_int, 1); +pub const __BIT_TYPES_DEFINED__ = @as(c_int, 1); +pub const _ENDIAN_H = @as(c_int, 1); +pub const _BITS_ENDIAN_H = @as(c_int, 1); +pub const __LITTLE_ENDIAN = @as(c_int, 1234); +pub const __BIG_ENDIAN = @as(c_int, 4321); +pub const __PDP_ENDIAN = @as(c_int, 3412); +pub const _BITS_ENDIANNESS_H = @as(c_int, 1); +pub const __BYTE_ORDER = __LITTLE_ENDIAN; +pub const __FLOAT_WORD_ORDER = __BYTE_ORDER; +pub inline fn __LONG_LONG_PAIR(HI: anytype, LO: anytype) @TypeOf(HI) { + return blk: { + _ = @TypeOf(LO); + break :blk HI; + }; +} +pub const LITTLE_ENDIAN = __LITTLE_ENDIAN; +pub const BIG_ENDIAN = __BIG_ENDIAN; +pub const PDP_ENDIAN = __PDP_ENDIAN; +pub const BYTE_ORDER = __BYTE_ORDER; +pub const _BITS_BYTESWAP_H = @as(c_int, 1); +pub inline fn __bswap_constant_16(x: anytype) __uint16_t { + return @import("std").zig.c_translation.cast(__uint16_t, ((x >> @as(c_int, 8)) & @as(c_int, 0xff)) | ((x & @as(c_int, 0xff)) << @as(c_int, 8))); +} +pub inline fn __bswap_constant_32(x: anytype) @TypeOf(((((x & @import("std").zig.c_translation.promoteIntLiteral(c_uint, 0xff000000, .hexadecimal)) >> @as(c_int, 24)) | ((x & @import("std").zig.c_translation.promoteIntLiteral(c_uint, 0x00ff0000, .hexadecimal)) >> @as(c_int, 8))) | ((x & @as(c_uint, 0x0000ff00)) << @as(c_int, 8))) | ((x & @as(c_uint, 0x000000ff)) << @as(c_int, 24))) { + return ((((x & @import("std").zig.c_translation.promoteIntLiteral(c_uint, 0xff000000, .hexadecimal)) >> @as(c_int, 24)) | ((x & @import("std").zig.c_translation.promoteIntLiteral(c_uint, 0x00ff0000, .hexadecimal)) >> @as(c_int, 8))) | ((x & @as(c_uint, 0x0000ff00)) << @as(c_int, 8))) | ((x & @as(c_uint, 0x000000ff)) << @as(c_int, 24)); +} +pub inline fn __bswap_constant_64(x: anytype) @TypeOf(((((((((x & @as(c_ulonglong, 0xff00000000000000)) >> @as(c_int, 56)) | ((x & @as(c_ulonglong, 0x00ff000000000000)) >> @as(c_int, 40))) | ((x & @as(c_ulonglong, 0x0000ff0000000000)) >> @as(c_int, 24))) | ((x & @as(c_ulonglong, 0x000000ff00000000)) >> @as(c_int, 8))) | ((x & @as(c_ulonglong, 0x00000000ff000000)) << @as(c_int, 8))) | ((x & @as(c_ulonglong, 0x0000000000ff0000)) << @as(c_int, 24))) | ((x & @as(c_ulonglong, 0x000000000000ff00)) << @as(c_int, 40))) | ((x & @as(c_ulonglong, 0x00000000000000ff)) << @as(c_int, 56))) { + return ((((((((x & @as(c_ulonglong, 0xff00000000000000)) >> @as(c_int, 56)) | ((x & @as(c_ulonglong, 0x00ff000000000000)) >> @as(c_int, 40))) | ((x & @as(c_ulonglong, 0x0000ff0000000000)) >> @as(c_int, 24))) | ((x & @as(c_ulonglong, 0x000000ff00000000)) >> @as(c_int, 8))) | ((x & @as(c_ulonglong, 0x00000000ff000000)) << @as(c_int, 8))) | ((x & @as(c_ulonglong, 0x0000000000ff0000)) << @as(c_int, 24))) | ((x & @as(c_ulonglong, 0x000000000000ff00)) << @as(c_int, 40))) | ((x & @as(c_ulonglong, 0x00000000000000ff)) << @as(c_int, 56)); +} +pub const _BITS_UINTN_IDENTITY_H = @as(c_int, 1); +pub inline fn htobe16(x: anytype) @TypeOf(__bswap_16(x)) { + return __bswap_16(x); +} +pub inline fn htole16(x: anytype) @TypeOf(__uint16_identity(x)) { + return __uint16_identity(x); +} +pub inline fn be16toh(x: anytype) @TypeOf(__bswap_16(x)) { + return __bswap_16(x); +} +pub inline fn le16toh(x: anytype) @TypeOf(__uint16_identity(x)) { + return __uint16_identity(x); +} +pub inline fn htobe32(x: anytype) @TypeOf(__bswap_32(x)) { + return __bswap_32(x); +} +pub inline fn htole32(x: anytype) @TypeOf(__uint32_identity(x)) { + return __uint32_identity(x); +} +pub inline fn be32toh(x: anytype) @TypeOf(__bswap_32(x)) { + return __bswap_32(x); +} +pub inline fn le32toh(x: anytype) @TypeOf(__uint32_identity(x)) { + return __uint32_identity(x); +} +pub inline fn htobe64(x: anytype) @TypeOf(__bswap_64(x)) { + return __bswap_64(x); +} +pub inline fn htole64(x: anytype) @TypeOf(__uint64_identity(x)) { + return __uint64_identity(x); +} +pub inline fn be64toh(x: anytype) @TypeOf(__bswap_64(x)) { + return __bswap_64(x); +} +pub inline fn le64toh(x: anytype) @TypeOf(__uint64_identity(x)) { + return __uint64_identity(x); +} +pub const _SYS_SELECT_H = @as(c_int, 1); +pub inline fn __FD_ISSET(d: anytype, s: anytype) @TypeOf((__FDS_BITS(s)[@intCast(usize, __FD_ELT(d))] & __FD_MASK(d)) != @as(c_int, 0)) { + return (__FDS_BITS(s)[@intCast(usize, __FD_ELT(d))] & __FD_MASK(d)) != @as(c_int, 0); +} +pub const __sigset_t_defined = @as(c_int, 1); +pub const ____sigset_t_defined = ""; +pub const _SIGSET_NWORDS = @import("std").zig.c_translation.MacroArithmetic.div(@as(c_int, 1024), @as(c_int, 8) * @import("std").zig.c_translation.sizeof(c_ulong)); +pub const __timeval_defined = @as(c_int, 1); +pub const _STRUCT_TIMESPEC = @as(c_int, 1); +pub const __suseconds_t_defined = ""; +pub const __NFDBITS = @as(c_int, 8) * @import("std").zig.c_translation.cast(c_int, @import("std").zig.c_translation.sizeof(__fd_mask)); +pub inline fn __FD_ELT(d: anytype) @TypeOf(@import("std").zig.c_translation.MacroArithmetic.div(d, __NFDBITS)) { + return @import("std").zig.c_translation.MacroArithmetic.div(d, __NFDBITS); +} +pub inline fn __FD_MASK(d: anytype) __fd_mask { + return @import("std").zig.c_translation.cast(__fd_mask, @as(c_ulong, 1) << @import("std").zig.c_translation.MacroArithmetic.rem(d, __NFDBITS)); +} +pub inline fn __FDS_BITS(set: anytype) @TypeOf(set.*.__fds_bits) { + return set.*.__fds_bits; +} +pub const FD_SETSIZE = __FD_SETSIZE; +pub const NFDBITS = __NFDBITS; +pub inline fn FD_SET(fd: anytype, fdsetp: anytype) @TypeOf(__FD_SET(fd, fdsetp)) { + return __FD_SET(fd, fdsetp); +} +pub inline fn FD_CLR(fd: anytype, fdsetp: anytype) @TypeOf(__FD_CLR(fd, fdsetp)) { + return __FD_CLR(fd, fdsetp); +} +pub inline fn FD_ISSET(fd: anytype, fdsetp: anytype) @TypeOf(__FD_ISSET(fd, fdsetp)) { + return __FD_ISSET(fd, fdsetp); +} +pub inline fn FD_ZERO(fdsetp: anytype) @TypeOf(__FD_ZERO(fdsetp)) { + return __FD_ZERO(fdsetp); +} +pub const __blksize_t_defined = ""; +pub const __blkcnt_t_defined = ""; +pub const __fsblkcnt_t_defined = ""; +pub const __fsfilcnt_t_defined = ""; +pub const _BITS_PTHREADTYPES_COMMON_H = @as(c_int, 1); +pub const _THREAD_SHARED_TYPES_H = @as(c_int, 1); +pub const _BITS_PTHREADTYPES_ARCH_H = @as(c_int, 1); +pub const __SIZEOF_PTHREAD_MUTEX_T = @as(c_int, 40); +pub const __SIZEOF_PTHREAD_ATTR_T = @as(c_int, 56); +pub const __SIZEOF_PTHREAD_RWLOCK_T = @as(c_int, 56); +pub const __SIZEOF_PTHREAD_BARRIER_T = @as(c_int, 32); +pub const __SIZEOF_PTHREAD_MUTEXATTR_T = @as(c_int, 4); +pub const __SIZEOF_PTHREAD_COND_T = @as(c_int, 48); +pub const __SIZEOF_PTHREAD_CONDATTR_T = @as(c_int, 4); +pub const __SIZEOF_PTHREAD_RWLOCKATTR_T = @as(c_int, 8); +pub const __SIZEOF_PTHREAD_BARRIERATTR_T = @as(c_int, 4); +pub const __LOCK_ALIGNMENT = ""; +pub const __ONCE_ALIGNMENT = ""; +pub const _BITS_ATOMIC_WIDE_COUNTER_H = ""; +pub const _THREAD_MUTEX_INTERNAL_H = @as(c_int, 1); +pub const __PTHREAD_MUTEX_HAVE_PREV = @as(c_int, 1); +pub const _RWLOCK_INTERNAL_H = ""; +pub inline fn __PTHREAD_RWLOCK_INITIALIZER(__flags: anytype) @TypeOf(__flags) { + return blk: { + _ = @as(c_int, 0); + _ = @as(c_int, 0); + _ = @as(c_int, 0); + _ = @as(c_int, 0); + _ = @as(c_int, 0); + _ = @as(c_int, 0); + _ = @as(c_int, 0); + _ = @as(c_int, 0); + _ = @TypeOf(__PTHREAD_RWLOCK_ELISION_EXTRA); + _ = @as(c_int, 0); + break :blk __flags; + }; +} +pub const __have_pthread_attr_t = @as(c_int, 1); +pub const _ALLOCA_H = @as(c_int, 1); +pub const __COMPAR_FN_T = ""; +pub const NVIM_MEMORY_H = ""; +pub const __STDDEF_H = ""; +pub const __need_ptrdiff_t = ""; +pub const __need_STDDEF_H_misc = ""; +pub const _PTRDIFF_T = ""; +pub const __CLANG_MAX_ALIGN_T_DEFINED = ""; +pub const _TIME_H = @as(c_int, 1); +pub const _BITS_TIME_H = @as(c_int, 1); +pub const CLOCKS_PER_SEC = @import("std").zig.c_translation.cast(__clock_t, @import("std").zig.c_translation.promoteIntLiteral(c_int, 1000000, .decimal)); +pub const CLOCK_REALTIME = @as(c_int, 0); +pub const CLOCK_MONOTONIC = @as(c_int, 1); +pub const CLOCK_PROCESS_CPUTIME_ID = @as(c_int, 2); +pub const CLOCK_THREAD_CPUTIME_ID = @as(c_int, 3); +pub const CLOCK_MONOTONIC_RAW = @as(c_int, 4); +pub const CLOCK_REALTIME_COARSE = @as(c_int, 5); +pub const CLOCK_MONOTONIC_COARSE = @as(c_int, 6); +pub const CLOCK_BOOTTIME = @as(c_int, 7); +pub const CLOCK_REALTIME_ALARM = @as(c_int, 8); +pub const CLOCK_BOOTTIME_ALARM = @as(c_int, 9); +pub const CLOCK_TAI = @as(c_int, 11); +pub const TIMER_ABSTIME = @as(c_int, 1); +pub const __struct_tm_defined = @as(c_int, 1); +pub const __itimerspec_defined = @as(c_int, 1); +pub const TIME_UTC = @as(c_int, 1); +pub inline fn __isleap(year: anytype) @TypeOf((@import("std").zig.c_translation.MacroArithmetic.rem(year, @as(c_int, 4)) == @as(c_int, 0)) and ((@import("std").zig.c_translation.MacroArithmetic.rem(year, @as(c_int, 100)) != @as(c_int, 0)) or (@import("std").zig.c_translation.MacroArithmetic.rem(year, @as(c_int, 400)) == @as(c_int, 0)))) { + return (@import("std").zig.c_translation.MacroArithmetic.rem(year, @as(c_int, 4)) == @as(c_int, 0)) and ((@import("std").zig.c_translation.MacroArithmetic.rem(year, @as(c_int, 100)) != @as(c_int, 0)) or (@import("std").zig.c_translation.MacroArithmetic.rem(year, @as(c_int, 400)) == @as(c_int, 0))); +} +pub const NVIM_MACROS_H = ""; +pub const AUTO_CONFIG_H = ""; +pub const SIZEOF_INT = @as(c_int, 4); +pub const SIZEOF_INTMAX_T = @as(c_int, 8); +pub const SIZEOF_LONG = @as(c_int, 8); +pub const SIZEOF_SIZE_T = @as(c_int, 8); +pub const ARCH_64 = ""; +pub const PROJECT_NAME = "nvim"; +pub const HAVE_FD_CLOEXEC = ""; +pub const HAVE_FSEEKO = ""; +pub const HAVE_LANGINFO_H = ""; +pub const HAVE_NL_LANGINFO_CODESET = ""; +pub const HAVE_NL_MSG_CAT_CNTR = ""; +pub const HAVE_PWD_FUNCS = ""; +pub const HAVE_READLINK = ""; +pub const HAVE_STRNLEN = ""; +pub const HAVE_STRCASECMP = ""; +pub const HAVE_STRINGS_H = ""; +pub const HAVE_STRNCASECMP = ""; +pub const HAVE_STRPTIME = ""; +pub const HAVE_SYS_SDT_H = ""; +pub const HAVE_SYS_UTSNAME_H = ""; +pub const HAVE_TERMIOS_H = ""; +pub const HAVE_WORKING_LIBINTL = ""; +pub const UNIX = ""; +pub const HAVE_SYS_UIO_H = ""; +pub const HAVE_READV = ""; +pub const HAVE_DIRFD_AND_FLOCK = ""; +pub const HAVE_FORKPTY = ""; +pub const HAVE_BE64TOH = ""; +pub const HAVE_EXECINFO_BACKTRACE = ""; +pub const HAVE_BUILTIN_ADD_OVERFLOW = ""; +pub const HAVE_WIMPLICIT_FALLTHROUGH_FLAG = ""; +pub inline fn MIN(X: anytype, Y: anytype) @TypeOf(if (X < Y) X else Y) { + return if (X < Y) X else Y; +} +pub inline fn MAX(X: anytype, Y: anytype) @TypeOf(if (X > Y) X else Y) { + return if (X > Y) X else Y; +} +pub inline fn S_LEN(s: anytype) @TypeOf(@import("std").zig.c_translation.sizeof(s) - @as(c_int, 1)) { + return blk: { + _ = @TypeOf(s); + break :blk @import("std").zig.c_translation.sizeof(s) - @as(c_int, 1); + }; +} +pub inline fn LINEEMPTY(p: anytype) @TypeOf(ml_get(p).* == NUL) { + return ml_get(p).* == NUL; +} +pub const TOUPPER_LOC = toupper; +pub const TOLOWER_LOC = tolower; +pub inline fn TOUPPER_ASC(c: anytype) @TypeOf(if ((c < 'a') or (c > 'z')) c else c - ('a' - 'A')) { + return if ((c < 'a') or (c > 'z')) c else c - ('a' - 'A'); +} +pub inline fn TOLOWER_ASC(c: anytype) @TypeOf(if ((c < 'A') or (c > 'Z')) c else c + ('a' - 'A')) { + return if ((c < 'A') or (c > 'Z')) c else c + ('a' - 'A'); +} +pub inline fn ASCII_ISLOWER(c: anytype) @TypeOf((@import("std").zig.c_translation.cast(c_uint, c) >= 'a') and (@import("std").zig.c_translation.cast(c_uint, c) <= 'z')) { + return (@import("std").zig.c_translation.cast(c_uint, c) >= 'a') and (@import("std").zig.c_translation.cast(c_uint, c) <= 'z'); +} +pub inline fn ASCII_ISUPPER(c: anytype) @TypeOf((@import("std").zig.c_translation.cast(c_uint, c) >= 'A') and (@import("std").zig.c_translation.cast(c_uint, c) <= 'Z')) { + return (@import("std").zig.c_translation.cast(c_uint, c) >= 'A') and (@import("std").zig.c_translation.cast(c_uint, c) <= 'Z'); +} +pub inline fn ASCII_ISALPHA(c: anytype) @TypeOf((ASCII_ISUPPER(c) != 0) or (ASCII_ISLOWER(c) != 0)) { + return (ASCII_ISUPPER(c) != 0) or (ASCII_ISLOWER(c) != 0); +} +pub inline fn ASCII_ISALNUM(c: anytype) @TypeOf((ASCII_ISALPHA(c) != 0) or (ascii_isdigit(c) != 0)) { + return (ASCII_ISALPHA(c) != 0) or (ascii_isdigit(c) != 0); +} +pub inline fn EMPTY_IF_NULL(x: anytype) @TypeOf(if (x) x else "") { + return if (x) x else ""; +} +pub const WRITEBIN = "wb"; +pub const READBIN = "rb"; +pub const APPENDBIN = "ab"; +pub inline fn MCH_OPEN_RW(n: anytype, f: anytype) @TypeOf(os_open(n, f, @import("std").zig.c_translation.cast(mode_t, @as(c_int, 0o600)))) { + return os_open(n, f, @import("std").zig.c_translation.cast(mode_t, @as(c_int, 0o600))); +} +pub inline fn REPLACE_NORMAL(s: anytype) @TypeOf(((s & REPLACE_FLAG) != 0) and !((s & VREPLACE_FLAG) != 0)) { + return ((s & REPLACE_FLAG) != 0) and !((s & VREPLACE_FLAG) != 0); +} +pub inline fn ARRAY_LAST_ENTRY(arr: anytype) @TypeOf(arr[@intCast(usize, ARRAY_SIZE(arr) - @as(c_int, 1))]) { + return arr[@intCast(usize, ARRAY_SIZE(arr) - @as(c_int, 1))]; +} +pub inline fn RGB_(r: anytype, g: anytype, b: anytype) @TypeOf(((r << @as(c_int, 16)) | (g << @as(c_int, 8))) | b) { + return ((r << @as(c_int, 16)) | (g << @as(c_int, 8))) | b; +} +pub inline fn STR(x: anytype) @TypeOf(STR_(x)) { + return STR_(x); +} +pub inline fn UV_BUF_LEN(x: anytype) @TypeOf(x) { + return x; +} +pub inline fn IO_COUNT(x: anytype) @TypeOf(x) { + return x; +} +pub inline fn EMPTY_POS(a: anytype) @TypeOf(((a.lnum == @as(c_int, 0)) and (a.col == @as(c_int, 0))) and (a.coladd == @as(c_int, 0))) { + return ((a.lnum == @as(c_int, 0)) and (a.col == @as(c_int, 0))) and (a.coladd == @as(c_int, 0)); +} +pub const ARENA_ALIGN = MAX(@import("std").zig.c_translation.sizeof(?*anyopaque), @import("std").zig.c_translation.sizeof(f64)); +pub const DEFINE_FUNC_ATTRIBUTES = ""; +pub const DID_REAL_ATTR = ""; +pub const FUNC_API_FAST = ""; +pub const FUNC_API_NOEXPORT = ""; +pub const FUNC_API_REMOTE_ONLY = ""; +pub const FUNC_API_LUA_ONLY = ""; +pub const FUNC_API_CHECK_TEXTLOCK = ""; +pub const FUNC_ATTR_MALLOC = REAL_FATTR_MALLOC; +pub inline fn FUNC_ATTR_ALLOC_SIZE(x: anytype) @TypeOf(REAL_FATTR_ALLOC_SIZE(x)) { + return REAL_FATTR_ALLOC_SIZE(x); +} +pub inline fn FUNC_ATTR_ALLOC_SIZE_PROD(x: anytype, y: anytype) @TypeOf(REAL_FATTR_ALLOC_SIZE_PROD(x, y)) { + return REAL_FATTR_ALLOC_SIZE_PROD(x, y); +} +pub inline fn FUNC_ATTR_ALLOC_ALIGN(x: anytype) @TypeOf(REAL_FATTR_ALLOC_ALIGN(x)) { + return REAL_FATTR_ALLOC_ALIGN(x); +} +pub const FUNC_ATTR_PURE = REAL_FATTR_PURE; +pub const FUNC_ATTR_CONST = REAL_FATTR_CONST; +pub const FUNC_ATTR_WARN_UNUSED_RESULT = REAL_FATTR_WARN_UNUSED_RESULT; +pub const FUNC_ATTR_ALWAYS_INLINE = REAL_FATTR_ALWAYS_INLINE; +pub const FUNC_ATTR_UNUSED = REAL_FATTR_UNUSED; +pub const FUNC_ATTR_NONNULL_ALL = REAL_FATTR_NONNULL_ALL; +pub const FUNC_ATTR_NONNULL_RET = REAL_FATTR_NONNULL_RET; +pub const FUNC_ATTR_NORETURN = REAL_FATTR_NORETURN; +pub const FUNC_ATTR_NO_SANITIZE_UNDEFINED = REAL_FATTR_NO_SANITIZE_UNDEFINED; +pub const FUNC_ATTR_NO_SANITIZE_ADDRESS = REAL_FATTR_NO_SANITIZE_ADDRESS; +pub inline fn FUNC_ATTR_PRINTF(x: anytype, y: anytype) @TypeOf(REAL_FATTR_PRINTF(x, y)) { + return REAL_FATTR_PRINTF(x, y); +} +pub const DLLEXPORT = ""; +pub const NVIM_OS_OS_DEFS_H = ""; +pub const _CTYPE_H = @as(c_int, 1); +pub inline fn _ISbit(bit: anytype) @TypeOf(if (bit < @as(c_int, 8)) (@as(c_int, 1) << bit) << @as(c_int, 8) else (@as(c_int, 1) << bit) >> @as(c_int, 8)) { + return if (bit < @as(c_int, 8)) (@as(c_int, 1) << bit) << @as(c_int, 8) else (@as(c_int, 1) << bit) >> @as(c_int, 8); +} +pub inline fn __isctype(c: anytype, @"type": anytype) @TypeOf(__ctype_b_loc().*[@intCast(usize, @import("std").zig.c_translation.cast(c_int, c))] & @import("std").zig.c_translation.cast(c_ushort, @"type")) { + return __ctype_b_loc().*[@intCast(usize, @import("std").zig.c_translation.cast(c_int, c))] & @import("std").zig.c_translation.cast(c_ushort, @"type"); +} +pub inline fn __isascii(c: anytype) @TypeOf((c & ~@as(c_int, 0x7f)) == @as(c_int, 0)) { + return (c & ~@as(c_int, 0x7f)) == @as(c_int, 0); +} +pub inline fn __toascii(c: anytype) @TypeOf(c & @as(c_int, 0x7f)) { + return c & @as(c_int, 0x7f); +} +pub inline fn __isctype_l(c: anytype, @"type": anytype, locale: anytype) @TypeOf(locale.*.__ctype_b[@intCast(usize, @import("std").zig.c_translation.cast(c_int, c))] & @import("std").zig.c_translation.cast(c_ushort, @"type")) { + return locale.*.__ctype_b[@intCast(usize, @import("std").zig.c_translation.cast(c_int, c))] & @import("std").zig.c_translation.cast(c_ushort, @"type"); +} +pub inline fn __isalnum_l(c: anytype, l: anytype) @TypeOf(__isctype_l(c, _ISalnum, l)) { + return __isctype_l(c, _ISalnum, l); +} +pub inline fn __isalpha_l(c: anytype, l: anytype) @TypeOf(__isctype_l(c, _ISalpha, l)) { + return __isctype_l(c, _ISalpha, l); +} +pub inline fn __iscntrl_l(c: anytype, l: anytype) @TypeOf(__isctype_l(c, _IScntrl, l)) { + return __isctype_l(c, _IScntrl, l); +} +pub inline fn __isdigit_l(c: anytype, l: anytype) @TypeOf(__isctype_l(c, _ISdigit, l)) { + return __isctype_l(c, _ISdigit, l); +} +pub inline fn __islower_l(c: anytype, l: anytype) @TypeOf(__isctype_l(c, _ISlower, l)) { + return __isctype_l(c, _ISlower, l); +} +pub inline fn __isgraph_l(c: anytype, l: anytype) @TypeOf(__isctype_l(c, _ISgraph, l)) { + return __isctype_l(c, _ISgraph, l); +} +pub inline fn __isprint_l(c: anytype, l: anytype) @TypeOf(__isctype_l(c, _ISprint, l)) { + return __isctype_l(c, _ISprint, l); +} +pub inline fn __ispunct_l(c: anytype, l: anytype) @TypeOf(__isctype_l(c, _ISpunct, l)) { + return __isctype_l(c, _ISpunct, l); +} +pub inline fn __isspace_l(c: anytype, l: anytype) @TypeOf(__isctype_l(c, _ISspace, l)) { + return __isctype_l(c, _ISspace, l); +} +pub inline fn __isupper_l(c: anytype, l: anytype) @TypeOf(__isctype_l(c, _ISupper, l)) { + return __isctype_l(c, _ISupper, l); +} +pub inline fn __isxdigit_l(c: anytype, l: anytype) @TypeOf(__isctype_l(c, _ISxdigit, l)) { + return __isctype_l(c, _ISxdigit, l); +} +pub inline fn __isblank_l(c: anytype, l: anytype) @TypeOf(__isctype_l(c, _ISblank, l)) { + return __isctype_l(c, _ISblank, l); +} +pub inline fn __isascii_l(c: anytype, l: anytype) @TypeOf(__isascii(c)) { + return blk_1: { + _ = @TypeOf(l); + break :blk_1 __isascii(c); + }; +} +pub inline fn __toascii_l(c: anytype, l: anytype) @TypeOf(__toascii(c)) { + return blk_1: { + _ = @TypeOf(l); + break :blk_1 __toascii(c); + }; +} +pub inline fn isascii_l(c: anytype, l: anytype) @TypeOf(__isascii_l(c, l)) { + return __isascii_l(c, l); +} +pub inline fn toascii_l(c: anytype, l: anytype) @TypeOf(__toascii_l(c, l)) { + return __toascii_l(c, l); +} +pub const _STDIO_H = @as(c_int, 1); +pub const __need___va_list = ""; +pub const __GNUC_VA_LIST = ""; +pub const _____fpos_t_defined = @as(c_int, 1); +pub const ____mbstate_t_defined = @as(c_int, 1); +pub const _____fpos64_t_defined = @as(c_int, 1); +pub const ____FILE_defined = @as(c_int, 1); +pub const __FILE_defined = @as(c_int, 1); +pub const __struct_FILE_defined = @as(c_int, 1); +pub const _IO_EOF_SEEN = @as(c_int, 0x0010); +pub inline fn __feof_unlocked_body(_fp: anytype) @TypeOf((_fp.*._flags & _IO_EOF_SEEN) != @as(c_int, 0)) { + return (_fp.*._flags & _IO_EOF_SEEN) != @as(c_int, 0); +} +pub const _IO_ERR_SEEN = @as(c_int, 0x0020); +pub inline fn __ferror_unlocked_body(_fp: anytype) @TypeOf((_fp.*._flags & _IO_ERR_SEEN) != @as(c_int, 0)) { + return (_fp.*._flags & _IO_ERR_SEEN) != @as(c_int, 0); +} +pub const _IO_USER_LOCK = @import("std").zig.c_translation.promoteIntLiteral(c_int, 0x8000, .hexadecimal); +pub const _VA_LIST_DEFINED = ""; +pub const _IOFBF = @as(c_int, 0); +pub const _IOLBF = @as(c_int, 1); +pub const _IONBF = @as(c_int, 2); +pub const BUFSIZ = @as(c_int, 8192); +pub const EOF = -@as(c_int, 1); +pub const SEEK_SET = @as(c_int, 0); +pub const SEEK_CUR = @as(c_int, 1); +pub const SEEK_END = @as(c_int, 2); +pub const P_tmpdir = "/tmp"; +pub const _BITS_STDIO_LIM_H = @as(c_int, 1); +pub const L_tmpnam = @as(c_int, 20); +pub const TMP_MAX = @import("std").zig.c_translation.promoteIntLiteral(c_int, 238328, .decimal); +pub const FILENAME_MAX = @as(c_int, 4096); +pub const L_ctermid = @as(c_int, 9); +pub const FOPEN_MAX = @as(c_int, 16); +pub const __attr_dealloc_fclose = __attr_dealloc(fclose, @as(c_int, 1)); +pub const _SYS_STAT_H = @as(c_int, 1); +pub const _BITS_STAT_H = @as(c_int, 1); +pub const _BITS_STRUCT_STAT_H = @as(c_int, 1); +pub const _STATBUF_ST_BLKSIZE = ""; +pub const _STATBUF_ST_RDEV = ""; +pub const _STATBUF_ST_NSEC = ""; +pub const __S_IFMT = @import("std").zig.c_translation.promoteIntLiteral(c_int, 0o170000, .octal); +pub const __S_IFDIR = @as(c_int, 0o040000); +pub const __S_IFCHR = @as(c_int, 0o020000); +pub const __S_IFBLK = @as(c_int, 0o060000); +pub const __S_IFREG = @import("std").zig.c_translation.promoteIntLiteral(c_int, 0o100000, .octal); +pub const __S_IFIFO = @as(c_int, 0o010000); +pub const __S_IFLNK = @import("std").zig.c_translation.promoteIntLiteral(c_int, 0o120000, .octal); +pub const __S_IFSOCK = @import("std").zig.c_translation.promoteIntLiteral(c_int, 0o140000, .octal); +pub inline fn __S_TYPEISMQ(buf: anytype) @TypeOf(buf.*.st_mode - buf.*.st_mode) { + return buf.*.st_mode - buf.*.st_mode; +} +pub inline fn __S_TYPEISSEM(buf: anytype) @TypeOf(buf.*.st_mode - buf.*.st_mode) { + return buf.*.st_mode - buf.*.st_mode; +} +pub inline fn __S_TYPEISSHM(buf: anytype) @TypeOf(buf.*.st_mode - buf.*.st_mode) { + return buf.*.st_mode - buf.*.st_mode; +} +pub const __S_ISUID = @as(c_int, 0o4000); +pub const __S_ISGID = @as(c_int, 0o2000); +pub const __S_ISVTX = @as(c_int, 0o1000); +pub const __S_IREAD = @as(c_int, 0o400); +pub const __S_IWRITE = @as(c_int, 0o200); +pub const __S_IEXEC = @as(c_int, 0o100); +pub const UTIME_NOW = (@as(c_long, 1) << @as(c_int, 30)) - @as(c_long, 1); +pub const UTIME_OMIT = (@as(c_long, 1) << @as(c_int, 30)) - @as(c_long, 2); +pub const S_IFMT = __S_IFMT; +pub const S_IFDIR = __S_IFDIR; +pub const S_IFCHR = __S_IFCHR; +pub const S_IFBLK = __S_IFBLK; +pub const S_IFREG = __S_IFREG; +pub const S_IFIFO = __S_IFIFO; +pub const S_IFLNK = __S_IFLNK; +pub const S_IFSOCK = __S_IFSOCK; +pub inline fn __S_ISTYPE(mode: anytype, mask: anytype) @TypeOf((mode & __S_IFMT) == mask) { + return (mode & __S_IFMT) == mask; +} +pub inline fn S_ISDIR(mode: anytype) @TypeOf(__S_ISTYPE(mode, __S_IFDIR)) { + return __S_ISTYPE(mode, __S_IFDIR); +} +pub inline fn S_ISCHR(mode: anytype) @TypeOf(__S_ISTYPE(mode, __S_IFCHR)) { + return __S_ISTYPE(mode, __S_IFCHR); +} +pub inline fn S_ISBLK(mode: anytype) @TypeOf(__S_ISTYPE(mode, __S_IFBLK)) { + return __S_ISTYPE(mode, __S_IFBLK); +} +pub inline fn S_ISREG(mode: anytype) @TypeOf(__S_ISTYPE(mode, __S_IFREG)) { + return __S_ISTYPE(mode, __S_IFREG); +} +pub inline fn S_ISFIFO(mode: anytype) @TypeOf(__S_ISTYPE(mode, __S_IFIFO)) { + return __S_ISTYPE(mode, __S_IFIFO); +} +pub inline fn S_ISLNK(mode: anytype) @TypeOf(__S_ISTYPE(mode, __S_IFLNK)) { + return __S_ISTYPE(mode, __S_IFLNK); +} +pub inline fn S_ISSOCK(mode: anytype) @TypeOf(__S_ISTYPE(mode, __S_IFSOCK)) { + return __S_ISTYPE(mode, __S_IFSOCK); +} +pub inline fn S_TYPEISMQ(buf: anytype) @TypeOf(__S_TYPEISMQ(buf)) { + return __S_TYPEISMQ(buf); +} +pub inline fn S_TYPEISSEM(buf: anytype) @TypeOf(__S_TYPEISSEM(buf)) { + return __S_TYPEISSEM(buf); +} +pub inline fn S_TYPEISSHM(buf: anytype) @TypeOf(__S_TYPEISSHM(buf)) { + return __S_TYPEISSHM(buf); +} +pub const S_ISUID = __S_ISUID; +pub const S_ISGID = __S_ISGID; +pub const S_ISVTX = __S_ISVTX; +pub const S_IRUSR = __S_IREAD; +pub const S_IWUSR = __S_IWRITE; +pub const S_IXUSR = __S_IEXEC; +pub const S_IRWXU = (__S_IREAD | __S_IWRITE) | __S_IEXEC; +pub const S_IREAD = S_IRUSR; +pub const S_IWRITE = S_IWUSR; +pub const S_IEXEC = S_IXUSR; +pub const S_IRGRP = S_IRUSR >> @as(c_int, 3); +pub const S_IWGRP = S_IWUSR >> @as(c_int, 3); +pub const S_IXGRP = S_IXUSR >> @as(c_int, 3); +pub const S_IRWXG = S_IRWXU >> @as(c_int, 3); +pub const S_IROTH = S_IRGRP >> @as(c_int, 3); +pub const S_IWOTH = S_IWGRP >> @as(c_int, 3); +pub const S_IXOTH = S_IXGRP >> @as(c_int, 3); +pub const S_IRWXO = S_IRWXG >> @as(c_int, 3); +pub const ACCESSPERMS = (S_IRWXU | S_IRWXG) | S_IRWXO; +pub const ALLPERMS = ((((S_ISUID | S_ISGID) | S_ISVTX) | S_IRWXU) | S_IRWXG) | S_IRWXO; +pub const DEFFILEMODE = ((((S_IRUSR | S_IWUSR) | S_IRGRP) | S_IWGRP) | S_IROTH) | S_IWOTH; +pub const S_BLKSIZE = @as(c_int, 512); +pub const NVIM_OS_UNIX_DEFS_H = ""; +pub const _SYS_PARAM_H = @as(c_int, 1); +pub const __CLANG_LIMITS_H = ""; +pub const _GCC_LIMITS_H_ = ""; +pub const _LIBC_LIMITS_H_ = @as(c_int, 1); +pub const MB_LEN_MAX = @as(c_int, 16); +pub const LLONG_MIN = -LLONG_MAX - @as(c_int, 1); +pub const LLONG_MAX = __LONG_LONG_MAX__; +pub const ULLONG_MAX = (LLONG_MAX * @as(c_ulonglong, 2)) + @as(c_int, 1); +pub const _BITS_POSIX1_LIM_H = @as(c_int, 1); +pub const _POSIX_AIO_LISTIO_MAX = @as(c_int, 2); +pub const _POSIX_AIO_MAX = @as(c_int, 1); +pub const _POSIX_ARG_MAX = @as(c_int, 4096); +pub const _POSIX_CHILD_MAX = @as(c_int, 25); +pub const _POSIX_DELAYTIMER_MAX = @as(c_int, 32); +pub const _POSIX_HOST_NAME_MAX = @as(c_int, 255); +pub const _POSIX_LINK_MAX = @as(c_int, 8); +pub const _POSIX_LOGIN_NAME_MAX = @as(c_int, 9); +pub const _POSIX_MAX_CANON = @as(c_int, 255); +pub const _POSIX_MAX_INPUT = @as(c_int, 255); +pub const _POSIX_MQ_OPEN_MAX = @as(c_int, 8); +pub const _POSIX_MQ_PRIO_MAX = @as(c_int, 32); +pub const _POSIX_NAME_MAX = @as(c_int, 14); +pub const _POSIX_NGROUPS_MAX = @as(c_int, 8); +pub const _POSIX_OPEN_MAX = @as(c_int, 20); +pub const _POSIX_PATH_MAX = @as(c_int, 256); +pub const _POSIX_PIPE_BUF = @as(c_int, 512); +pub const _POSIX_RE_DUP_MAX = @as(c_int, 255); +pub const _POSIX_RTSIG_MAX = @as(c_int, 8); +pub const _POSIX_SEM_NSEMS_MAX = @as(c_int, 256); +pub const _POSIX_SEM_VALUE_MAX = @as(c_int, 32767); +pub const _POSIX_SIGQUEUE_MAX = @as(c_int, 32); +pub const _POSIX_SSIZE_MAX = @as(c_int, 32767); +pub const _POSIX_STREAM_MAX = @as(c_int, 8); +pub const _POSIX_SYMLINK_MAX = @as(c_int, 255); +pub const _POSIX_SYMLOOP_MAX = @as(c_int, 8); +pub const _POSIX_TIMER_MAX = @as(c_int, 32); +pub const _POSIX_TTY_NAME_MAX = @as(c_int, 9); +pub const _POSIX_TZNAME_MAX = @as(c_int, 6); +pub const _POSIX_CLOCKRES_MIN = @import("std").zig.c_translation.promoteIntLiteral(c_int, 20000000, .decimal); +pub const __undef_NR_OPEN = ""; +pub const __undef_LINK_MAX = ""; +pub const __undef_OPEN_MAX = ""; +pub const __undef_ARG_MAX = ""; +pub const _LINUX_LIMITS_H = ""; +pub const NR_OPEN = @as(c_int, 1024); +pub const NGROUPS_MAX = @import("std").zig.c_translation.promoteIntLiteral(c_int, 65536, .decimal); +pub const ARG_MAX = @import("std").zig.c_translation.promoteIntLiteral(c_int, 131072, .decimal); +pub const LINK_MAX = @as(c_int, 127); +pub const MAX_CANON = @as(c_int, 255); +pub const MAX_INPUT = @as(c_int, 255); +pub const NAME_MAX = @as(c_int, 255); +pub const PATH_MAX = @as(c_int, 4096); +pub const PIPE_BUF = @as(c_int, 4096); +pub const XATTR_NAME_MAX = @as(c_int, 255); +pub const XATTR_SIZE_MAX = @import("std").zig.c_translation.promoteIntLiteral(c_int, 65536, .decimal); +pub const XATTR_LIST_MAX = @import("std").zig.c_translation.promoteIntLiteral(c_int, 65536, .decimal); +pub const RTSIG_MAX = @as(c_int, 32); +pub const _POSIX_THREAD_KEYS_MAX = @as(c_int, 128); +pub const PTHREAD_KEYS_MAX = @as(c_int, 1024); +pub const _POSIX_THREAD_DESTRUCTOR_ITERATIONS = @as(c_int, 4); +pub const PTHREAD_DESTRUCTOR_ITERATIONS = _POSIX_THREAD_DESTRUCTOR_ITERATIONS; +pub const _POSIX_THREAD_THREADS_MAX = @as(c_int, 64); +pub const AIO_PRIO_DELTA_MAX = @as(c_int, 20); +pub const PTHREAD_STACK_MIN = @as(c_int, 16384); +pub const DELAYTIMER_MAX = @import("std").zig.c_translation.promoteIntLiteral(c_int, 2147483647, .decimal); +pub const TTY_NAME_MAX = @as(c_int, 32); +pub const LOGIN_NAME_MAX = @as(c_int, 256); +pub const HOST_NAME_MAX = @as(c_int, 64); +pub const MQ_PRIO_MAX = @import("std").zig.c_translation.promoteIntLiteral(c_int, 32768, .decimal); +pub const SEM_VALUE_MAX = @import("std").zig.c_translation.promoteIntLiteral(c_int, 2147483647, .decimal); +pub const SSIZE_MAX = LONG_MAX; +pub const _BITS_POSIX2_LIM_H = @as(c_int, 1); +pub const _POSIX2_BC_BASE_MAX = @as(c_int, 99); +pub const _POSIX2_BC_DIM_MAX = @as(c_int, 2048); +pub const _POSIX2_BC_SCALE_MAX = @as(c_int, 99); +pub const _POSIX2_BC_STRING_MAX = @as(c_int, 1000); +pub const _POSIX2_COLL_WEIGHTS_MAX = @as(c_int, 2); +pub const _POSIX2_EXPR_NEST_MAX = @as(c_int, 32); +pub const _POSIX2_LINE_MAX = @as(c_int, 2048); +pub const _POSIX2_RE_DUP_MAX = @as(c_int, 255); +pub const _POSIX2_CHARCLASS_NAME_MAX = @as(c_int, 14); +pub const BC_BASE_MAX = _POSIX2_BC_BASE_MAX; +pub const BC_DIM_MAX = _POSIX2_BC_DIM_MAX; +pub const BC_SCALE_MAX = _POSIX2_BC_SCALE_MAX; +pub const BC_STRING_MAX = _POSIX2_BC_STRING_MAX; +pub const COLL_WEIGHTS_MAX = @as(c_int, 255); +pub const EXPR_NEST_MAX = _POSIX2_EXPR_NEST_MAX; +pub const LINE_MAX = _POSIX2_LINE_MAX; +pub const CHARCLASS_NAME_MAX = @as(c_int, 2048); +pub const RE_DUP_MAX = @as(c_int, 0x7fff); +pub const SCHAR_MAX = __SCHAR_MAX__; +pub const SHRT_MAX = __SHRT_MAX__; +pub const INT_MAX = __INT_MAX__; +pub const LONG_MAX = __LONG_MAX__; +pub const SCHAR_MIN = -__SCHAR_MAX__ - @as(c_int, 1); +pub const SHRT_MIN = -__SHRT_MAX__ - @as(c_int, 1); +pub const INT_MIN = -__INT_MAX__ - @as(c_int, 1); +pub const LONG_MIN = -__LONG_MAX__ - @as(c_long, 1); +pub const UCHAR_MAX = (__SCHAR_MAX__ * @as(c_int, 2)) + @as(c_int, 1); +pub const USHRT_MAX = (__SHRT_MAX__ * @as(c_int, 2)) + @as(c_int, 1); +pub const UINT_MAX = (__INT_MAX__ * @as(c_uint, 2)) + @as(c_uint, 1); +pub const ULONG_MAX = (__LONG_MAX__ * @as(c_ulong, 2)) + @as(c_ulong, 1); +pub const CHAR_BIT = __CHAR_BIT__; +pub const CHAR_MIN = SCHAR_MIN; +pub const CHAR_MAX = __SCHAR_MAX__; +pub const _SIGNAL_H = ""; +pub const _BITS_SIGNUM_GENERIC_H = @as(c_int, 1); +pub const SIG_ERR = @import("std").zig.c_translation.cast(__sighandler_t, -@as(c_int, 1)); +pub const SIG_DFL = @import("std").zig.c_translation.cast(__sighandler_t, @as(c_int, 0)); +pub const SIG_IGN = @import("std").zig.c_translation.cast(__sighandler_t, @as(c_int, 1)); +pub const SIGINT = @as(c_int, 2); +pub const SIGILL = @as(c_int, 4); +pub const SIGABRT = @as(c_int, 6); +pub const SIGFPE = @as(c_int, 8); +pub const SIGSEGV = @as(c_int, 11); +pub const SIGTERM = @as(c_int, 15); +pub const SIGHUP = @as(c_int, 1); +pub const SIGQUIT = @as(c_int, 3); +pub const SIGTRAP = @as(c_int, 5); +pub const SIGKILL = @as(c_int, 9); +pub const SIGPIPE = @as(c_int, 13); +pub const SIGALRM = @as(c_int, 14); +pub const SIGIO = SIGPOLL; +pub const SIGIOT = SIGABRT; +pub const SIGCLD = SIGCHLD; +pub const _BITS_SIGNUM_ARCH_H = @as(c_int, 1); +pub const SIGSTKFLT = @as(c_int, 16); +pub const SIGPWR = @as(c_int, 30); +pub const SIGBUS = @as(c_int, 7); +pub const SIGSYS = @as(c_int, 31); +pub const SIGURG = @as(c_int, 23); +pub const SIGSTOP = @as(c_int, 19); +pub const SIGTSTP = @as(c_int, 20); +pub const SIGCONT = @as(c_int, 18); +pub const SIGCHLD = @as(c_int, 17); +pub const SIGTTIN = @as(c_int, 21); +pub const SIGTTOU = @as(c_int, 22); +pub const SIGPOLL = @as(c_int, 29); +pub const SIGXFSZ = @as(c_int, 25); +pub const SIGXCPU = @as(c_int, 24); +pub const SIGVTALRM = @as(c_int, 26); +pub const SIGPROF = @as(c_int, 27); +pub const SIGUSR1 = @as(c_int, 10); +pub const SIGUSR2 = @as(c_int, 12); +pub const SIGWINCH = @as(c_int, 28); +pub const __SIGRTMIN = @as(c_int, 32); +pub const __SIGRTMAX = @as(c_int, 64); +pub const _NSIG = __SIGRTMAX + @as(c_int, 1); +pub const __sig_atomic_t_defined = @as(c_int, 1); +pub const __siginfo_t_defined = @as(c_int, 1); +pub const ____sigval_t_defined = ""; +pub const __SI_MAX_SIZE = @as(c_int, 128); +pub const __SI_PAD_SIZE = @import("std").zig.c_translation.MacroArithmetic.div(__SI_MAX_SIZE, @import("std").zig.c_translation.sizeof(c_int)) - @as(c_int, 4); +pub const _BITS_SIGINFO_ARCH_H = @as(c_int, 1); +pub const __SI_ALIGNMENT = ""; +pub const __SI_BAND_TYPE = c_long; +pub const __SI_CLOCK_T = __clock_t; +pub const __SI_ERRNO_THEN_CODE = @as(c_int, 1); +pub const __SI_HAVE_SIGSYS = @as(c_int, 1); +pub const __SI_SIGFAULT_ADDL = ""; +pub const _BITS_SIGINFO_CONSTS_H = @as(c_int, 1); +pub const __SI_ASYNCIO_AFTER_SIGIO = @as(c_int, 1); +pub const __sigval_t_defined = ""; +pub const __sigevent_t_defined = @as(c_int, 1); +pub const __SIGEV_MAX_SIZE = @as(c_int, 64); +pub const __SIGEV_PAD_SIZE = @import("std").zig.c_translation.MacroArithmetic.div(__SIGEV_MAX_SIZE, @import("std").zig.c_translation.sizeof(c_int)) - @as(c_int, 4); +pub const _BITS_SIGEVENT_CONSTS_H = @as(c_int, 1); +pub inline fn sigmask(sig: anytype) @TypeOf(__glibc_macro_warning("sigmask is deprecated")(@import("std").zig.c_translation.cast(c_int, @as(c_uint, 1) << (sig - @as(c_int, 1))))) { + return __glibc_macro_warning("sigmask is deprecated")(@import("std").zig.c_translation.cast(c_int, @as(c_uint, 1) << (sig - @as(c_int, 1)))); +} +pub const NSIG = _NSIG; +pub const _BITS_SIGACTION_H = @as(c_int, 1); +pub const SA_NOCLDSTOP = @as(c_int, 1); +pub const SA_NOCLDWAIT = @as(c_int, 2); +pub const SA_SIGINFO = @as(c_int, 4); +pub const SA_ONSTACK = @import("std").zig.c_translation.promoteIntLiteral(c_int, 0x08000000, .hexadecimal); +pub const SA_RESTART = @import("std").zig.c_translation.promoteIntLiteral(c_int, 0x10000000, .hexadecimal); +pub const SA_NODEFER = @import("std").zig.c_translation.promoteIntLiteral(c_int, 0x40000000, .hexadecimal); +pub const SA_RESETHAND = @import("std").zig.c_translation.promoteIntLiteral(c_int, 0x80000000, .hexadecimal); +pub const SA_INTERRUPT = @import("std").zig.c_translation.promoteIntLiteral(c_int, 0x20000000, .hexadecimal); +pub const SA_NOMASK = SA_NODEFER; +pub const SA_ONESHOT = SA_RESETHAND; +pub const SA_STACK = SA_ONSTACK; +pub const SIG_BLOCK = @as(c_int, 0); +pub const SIG_UNBLOCK = @as(c_int, 1); +pub const SIG_SETMASK = @as(c_int, 2); +pub const _BITS_SIGCONTEXT_H = @as(c_int, 1); +pub const FP_XSTATE_MAGIC1 = @import("std").zig.c_translation.promoteIntLiteral(c_uint, 0x46505853, .hexadecimal); +pub const FP_XSTATE_MAGIC2 = @import("std").zig.c_translation.promoteIntLiteral(c_uint, 0x46505845, .hexadecimal); +pub const FP_XSTATE_MAGIC2_SIZE = @import("std").zig.c_translation.sizeof(FP_XSTATE_MAGIC2); +pub const __stack_t_defined = @as(c_int, 1); +pub const _SYS_UCONTEXT_H = @as(c_int, 1); +pub inline fn __ctx(fld: anytype) @TypeOf(fld) { + return fld; +} +pub const __NGREG = @as(c_int, 23); +pub const NGREG = __NGREG; +pub const _BITS_SIGSTACK_H = @as(c_int, 1); +pub const MINSIGSTKSZ = @as(c_int, 2048); +pub const SIGSTKSZ = @as(c_int, 8192); +pub const _BITS_SS_FLAGS_H = @as(c_int, 1); +pub const __sigstack_defined = @as(c_int, 1); +pub const _BITS_SIGTHREAD_H = @as(c_int, 1); +pub const SIGRTMIN = __libc_current_sigrtmin(); +pub const SIGRTMAX = __libc_current_sigrtmax(); +pub const _LINUX_PARAM_H = ""; +pub const __ASM_GENERIC_PARAM_H = ""; +pub const HZ = @as(c_int, 100); +pub const EXEC_PAGESIZE = @as(c_int, 4096); +pub const NOGROUP = -@as(c_int, 1); +pub const MAXHOSTNAMELEN = @as(c_int, 64); +pub const MAXSYMLINKS = @as(c_int, 20); +pub const NOFILE = @as(c_int, 256); +pub const NCARGS = @import("std").zig.c_translation.promoteIntLiteral(c_int, 131072, .decimal); +pub const NBBY = CHAR_BIT; +pub const NGROUPS = NGROUPS_MAX; +pub const CANBSIZ = MAX_CANON; +pub const MAXPATHLEN = PATH_MAX; +pub const NODEV = @import("std").zig.c_translation.cast(dev_t, -@as(c_int, 1)); +pub const DEV_BSIZE = @as(c_int, 512); +pub inline fn isset(a: anytype, i: anytype) @TypeOf(a[@intCast(usize, @import("std").zig.c_translation.MacroArithmetic.div(i, NBBY))] & (@as(c_int, 1) << @import("std").zig.c_translation.MacroArithmetic.rem(i, NBBY))) { + return a[@intCast(usize, @import("std").zig.c_translation.MacroArithmetic.div(i, NBBY))] & (@as(c_int, 1) << @import("std").zig.c_translation.MacroArithmetic.rem(i, NBBY)); +} +pub inline fn isclr(a: anytype, i: anytype) @TypeOf((a[@intCast(usize, @import("std").zig.c_translation.MacroArithmetic.div(i, NBBY))] & (@as(c_int, 1) << @import("std").zig.c_translation.MacroArithmetic.rem(i, NBBY))) == @as(c_int, 0)) { + return (a[@intCast(usize, @import("std").zig.c_translation.MacroArithmetic.div(i, NBBY))] & (@as(c_int, 1) << @import("std").zig.c_translation.MacroArithmetic.rem(i, NBBY))) == @as(c_int, 0); +} +pub inline fn howmany(x: anytype, y: anytype) @TypeOf(@import("std").zig.c_translation.MacroArithmetic.div(x + (y - @as(c_int, 1)), y)) { + return @import("std").zig.c_translation.MacroArithmetic.div(x + (y - @as(c_int, 1)), y); +} +pub inline fn roundup(x: anytype, y: anytype) @TypeOf(if ((__builtin_constant_p(y) != 0) and (powerof2(y) != 0)) ((x + y) - @as(c_int, 1)) & ~(y - @as(c_int, 1)) else @import("std").zig.c_translation.MacroArithmetic.div(x + (y - @as(c_int, 1)), y) * y) { + return if ((__builtin_constant_p(y) != 0) and (powerof2(y) != 0)) ((x + y) - @as(c_int, 1)) & ~(y - @as(c_int, 1)) else @import("std").zig.c_translation.MacroArithmetic.div(x + (y - @as(c_int, 1)), y) * y; +} +pub inline fn powerof2(x: anytype) @TypeOf(((x - @as(c_int, 1)) & x) == @as(c_int, 0)) { + return ((x - @as(c_int, 1)) & x) == @as(c_int, 0); +} +pub const _UNISTD_H = @as(c_int, 1); +pub const _POSIX_VERSION = @as(c_long, 200809); +pub const __POSIX2_THIS_VERSION = @as(c_long, 200809); +pub const _POSIX2_VERSION = __POSIX2_THIS_VERSION; +pub const _POSIX2_C_VERSION = __POSIX2_THIS_VERSION; +pub const _POSIX2_C_BIND = __POSIX2_THIS_VERSION; +pub const _POSIX2_C_DEV = __POSIX2_THIS_VERSION; +pub const _POSIX2_SW_DEV = __POSIX2_THIS_VERSION; +pub const _POSIX2_LOCALEDEF = __POSIX2_THIS_VERSION; +pub const _XOPEN_VERSION = @as(c_int, 700); +pub const _XOPEN_XCU_VERSION = @as(c_int, 4); +pub const _XOPEN_XPG2 = @as(c_int, 1); +pub const _XOPEN_XPG3 = @as(c_int, 1); +pub const _XOPEN_XPG4 = @as(c_int, 1); +pub const _XOPEN_UNIX = @as(c_int, 1); +pub const _XOPEN_ENH_I18N = @as(c_int, 1); +pub const _XOPEN_LEGACY = @as(c_int, 1); +pub const _BITS_POSIX_OPT_H = @as(c_int, 1); +pub const _POSIX_JOB_CONTROL = @as(c_int, 1); +pub const _POSIX_SAVED_IDS = @as(c_int, 1); +pub const _POSIX_PRIORITY_SCHEDULING = @as(c_long, 200809); +pub const _POSIX_SYNCHRONIZED_IO = @as(c_long, 200809); +pub const _POSIX_FSYNC = @as(c_long, 200809); +pub const _POSIX_MAPPED_FILES = @as(c_long, 200809); +pub const _POSIX_MEMLOCK = @as(c_long, 200809); +pub const _POSIX_MEMLOCK_RANGE = @as(c_long, 200809); +pub const _POSIX_MEMORY_PROTECTION = @as(c_long, 200809); +pub const _POSIX_CHOWN_RESTRICTED = @as(c_int, 0); +pub const _POSIX_VDISABLE = '\x00'; +pub const _POSIX_NO_TRUNC = @as(c_int, 1); +pub const _XOPEN_REALTIME = @as(c_int, 1); +pub const _XOPEN_REALTIME_THREADS = @as(c_int, 1); +pub const _XOPEN_SHM = @as(c_int, 1); +pub const _POSIX_THREADS = @as(c_long, 200809); +pub const _POSIX_REENTRANT_FUNCTIONS = @as(c_int, 1); +pub const _POSIX_THREAD_SAFE_FUNCTIONS = @as(c_long, 200809); +pub const _POSIX_THREAD_PRIORITY_SCHEDULING = @as(c_long, 200809); +pub const _POSIX_THREAD_ATTR_STACKSIZE = @as(c_long, 200809); +pub const _POSIX_THREAD_ATTR_STACKADDR = @as(c_long, 200809); +pub const _POSIX_THREAD_PRIO_INHERIT = @as(c_long, 200809); +pub const _POSIX_THREAD_PRIO_PROTECT = @as(c_long, 200809); +pub const _POSIX_THREAD_ROBUST_PRIO_INHERIT = @as(c_long, 200809); +pub const _POSIX_THREAD_ROBUST_PRIO_PROTECT = -@as(c_int, 1); +pub const _POSIX_SEMAPHORES = @as(c_long, 200809); +pub const _POSIX_REALTIME_SIGNALS = @as(c_long, 200809); +pub const _POSIX_ASYNCHRONOUS_IO = @as(c_long, 200809); +pub const _POSIX_ASYNC_IO = @as(c_int, 1); +pub const _LFS_ASYNCHRONOUS_IO = @as(c_int, 1); +pub const _POSIX_PRIORITIZED_IO = @as(c_long, 200809); +pub const _LFS64_ASYNCHRONOUS_IO = @as(c_int, 1); +pub const _LFS_LARGEFILE = @as(c_int, 1); +pub const _LFS64_LARGEFILE = @as(c_int, 1); +pub const _LFS64_STDIO = @as(c_int, 1); +pub const _POSIX_SHARED_MEMORY_OBJECTS = @as(c_long, 200809); +pub const _POSIX_CPUTIME = @as(c_int, 0); +pub const _POSIX_THREAD_CPUTIME = @as(c_int, 0); +pub const _POSIX_REGEXP = @as(c_int, 1); +pub const _POSIX_READER_WRITER_LOCKS = @as(c_long, 200809); +pub const _POSIX_SHELL = @as(c_int, 1); +pub const _POSIX_TIMEOUTS = @as(c_long, 200809); +pub const _POSIX_SPIN_LOCKS = @as(c_long, 200809); +pub const _POSIX_SPAWN = @as(c_long, 200809); +pub const _POSIX_TIMERS = @as(c_long, 200809); +pub const _POSIX_BARRIERS = @as(c_long, 200809); +pub const _POSIX_MESSAGE_PASSING = @as(c_long, 200809); +pub const _POSIX_THREAD_PROCESS_SHARED = @as(c_long, 200809); +pub const _POSIX_MONOTONIC_CLOCK = @as(c_int, 0); +pub const _POSIX_CLOCK_SELECTION = @as(c_long, 200809); +pub const _POSIX_ADVISORY_INFO = @as(c_long, 200809); +pub const _POSIX_IPV6 = @as(c_long, 200809); +pub const _POSIX_RAW_SOCKETS = @as(c_long, 200809); +pub const _POSIX2_CHAR_TERM = @as(c_long, 200809); +pub const _POSIX_SPORADIC_SERVER = -@as(c_int, 1); +pub const _POSIX_THREAD_SPORADIC_SERVER = -@as(c_int, 1); +pub const _POSIX_TRACE = -@as(c_int, 1); +pub const _POSIX_TRACE_EVENT_FILTER = -@as(c_int, 1); +pub const _POSIX_TRACE_INHERIT = -@as(c_int, 1); +pub const _POSIX_TRACE_LOG = -@as(c_int, 1); +pub const _POSIX_TYPED_MEMORY_OBJECTS = -@as(c_int, 1); +pub const _POSIX_V7_LPBIG_OFFBIG = -@as(c_int, 1); +pub const _POSIX_V6_LPBIG_OFFBIG = -@as(c_int, 1); +pub const _XBS5_LPBIG_OFFBIG = -@as(c_int, 1); +pub const _POSIX_V7_LP64_OFF64 = @as(c_int, 1); +pub const _POSIX_V6_LP64_OFF64 = @as(c_int, 1); +pub const _XBS5_LP64_OFF64 = @as(c_int, 1); +pub const __ILP32_OFF32_CFLAGS = "-m32"; +pub const __ILP32_OFF32_LDFLAGS = "-m32"; +pub const __ILP32_OFFBIG_CFLAGS = "-m32 -D_LARGEFILE_SOURCE -D_FILE_OFFSET_BITS=64"; +pub const __ILP32_OFFBIG_LDFLAGS = "-m32"; +pub const __LP64_OFF64_CFLAGS = "-m64"; +pub const __LP64_OFF64_LDFLAGS = "-m64"; +pub const STDIN_FILENO = @as(c_int, 0); +pub const STDOUT_FILENO = @as(c_int, 1); +pub const STDERR_FILENO = @as(c_int, 2); +pub const __useconds_t_defined = ""; +pub const __socklen_t_defined = ""; +pub const R_OK = @as(c_int, 4); +pub const W_OK = @as(c_int, 2); +pub const X_OK = @as(c_int, 1); +pub const F_OK = @as(c_int, 0); +pub const L_SET = SEEK_SET; +pub const L_INCR = SEEK_CUR; +pub const L_XTND = SEEK_END; +pub const _SC_PAGE_SIZE = _SC_PAGESIZE; +pub const _CS_POSIX_V6_WIDTH_RESTRICTED_ENVS = _CS_V6_WIDTH_RESTRICTED_ENVS; +pub const _CS_POSIX_V5_WIDTH_RESTRICTED_ENVS = _CS_V5_WIDTH_RESTRICTED_ENVS; +pub const _CS_POSIX_V7_WIDTH_RESTRICTED_ENVS = _CS_V7_WIDTH_RESTRICTED_ENVS; +pub const _GETOPT_POSIX_H = @as(c_int, 1); +pub const _GETOPT_CORE_H = @as(c_int, 1); +pub const F_ULOCK = @as(c_int, 0); +pub const F_LOCK = @as(c_int, 1); +pub const F_TLOCK = @as(c_int, 2); +pub const F_TEST = @as(c_int, 3); +pub const _TERMIOS_H = @as(c_int, 1); +pub const NCCS = @as(c_int, 32); +pub const _HAVE_STRUCT_TERMIOS_C_ISPEED = @as(c_int, 1); +pub const _HAVE_STRUCT_TERMIOS_C_OSPEED = @as(c_int, 1); +pub const VINTR = @as(c_int, 0); +pub const VQUIT = @as(c_int, 1); +pub const VERASE = @as(c_int, 2); +pub const VKILL = @as(c_int, 3); +pub const VEOF = @as(c_int, 4); +pub const VTIME = @as(c_int, 5); +pub const VMIN = @as(c_int, 6); +pub const VSWTC = @as(c_int, 7); +pub const VSTART = @as(c_int, 8); +pub const VSTOP = @as(c_int, 9); +pub const VSUSP = @as(c_int, 10); +pub const VEOL = @as(c_int, 11); +pub const VREPRINT = @as(c_int, 12); +pub const VDISCARD = @as(c_int, 13); +pub const VWERASE = @as(c_int, 14); +pub const VLNEXT = @as(c_int, 15); +pub const VEOL2 = @as(c_int, 16); +pub const IGNBRK = @as(c_int, 0o000001); +pub const BRKINT = @as(c_int, 0o000002); +pub const IGNPAR = @as(c_int, 0o000004); +pub const PARMRK = @as(c_int, 0o000010); +pub const INPCK = @as(c_int, 0o000020); +pub const ISTRIP = @as(c_int, 0o000040); +pub const INLCR = @as(c_int, 0o000100); +pub const IGNCR = @as(c_int, 0o000200); +pub const ICRNL = @as(c_int, 0o000400); +pub const IUCLC = @as(c_int, 0o001000); +pub const IXON = @as(c_int, 0o002000); +pub const IXANY = @as(c_int, 0o004000); +pub const IXOFF = @as(c_int, 0o010000); +pub const IMAXBEL = @as(c_int, 0o020000); +pub const IUTF8 = @as(c_int, 0o040000); +pub const OPOST = @as(c_int, 0o000001); +pub const OLCUC = @as(c_int, 0o000002); +pub const ONLCR = @as(c_int, 0o000004); +pub const OCRNL = @as(c_int, 0o000010); +pub const ONOCR = @as(c_int, 0o000020); +pub const ONLRET = @as(c_int, 0o000040); +pub const OFILL = @as(c_int, 0o000100); +pub const OFDEL = @as(c_int, 0o000200); +pub const NLDLY = @as(c_int, 0o000400); +pub const NL0 = @as(c_int, 0o000000); +pub const NL1 = @as(c_int, 0o000400); +pub const CRDLY = @as(c_int, 0o003000); +pub const CR0 = @as(c_int, 0o000000); +pub const CR1 = @as(c_int, 0o001000); +pub const CR2 = @as(c_int, 0o002000); +pub const CR3 = @as(c_int, 0o003000); +pub const TABDLY = @as(c_int, 0o014000); +pub const TAB0 = @as(c_int, 0o000000); +pub const TAB1 = @as(c_int, 0o004000); +pub const TAB2 = @as(c_int, 0o010000); +pub const TAB3 = @as(c_int, 0o014000); +pub const BSDLY = @as(c_int, 0o020000); +pub const BS0 = @as(c_int, 0o000000); +pub const BS1 = @as(c_int, 0o020000); +pub const FFDLY = @import("std").zig.c_translation.promoteIntLiteral(c_int, 0o100000, .octal); +pub const FF0 = @as(c_int, 0o000000); +pub const FF1 = @import("std").zig.c_translation.promoteIntLiteral(c_int, 0o100000, .octal); +pub const VTDLY = @as(c_int, 0o040000); +pub const VT0 = @as(c_int, 0o000000); +pub const VT1 = @as(c_int, 0o040000); +pub const XTABS = @as(c_int, 0o014000); +pub const B0 = @as(c_int, 0o000000); +pub const B50 = @as(c_int, 0o000001); +pub const B75 = @as(c_int, 0o000002); +pub const B110 = @as(c_int, 0o000003); +pub const B134 = @as(c_int, 0o000004); +pub const B150 = @as(c_int, 0o000005); +pub const B200 = @as(c_int, 0o000006); +pub const B300 = @as(c_int, 0o000007); +pub const B600 = @as(c_int, 0o000010); +pub const B1200 = @as(c_int, 0o000011); +pub const B1800 = @as(c_int, 0o000012); +pub const B2400 = @as(c_int, 0o000013); +pub const B4800 = @as(c_int, 0o000014); +pub const B9600 = @as(c_int, 0o000015); +pub const B19200 = @as(c_int, 0o000016); +pub const B38400 = @as(c_int, 0o000017); +pub const EXTA = B19200; +pub const EXTB = B38400; +pub const CBAUD = @as(c_int, 0o00000010017); +pub const CBAUDEX = @as(c_int, 0o00000010000); +pub const CIBAUD = @import("std").zig.c_translation.promoteIntLiteral(c_int, 0o02003600000, .octal); +pub const CMSPAR = @import("std").zig.c_translation.promoteIntLiteral(c_int, 0o10000000000, .octal); +pub const CRTSCTS = @import("std").zig.c_translation.promoteIntLiteral(c_int, 0o20000000000, .octal); +pub const B57600 = @as(c_int, 0o010001); +pub const B115200 = @as(c_int, 0o010002); +pub const B230400 = @as(c_int, 0o010003); +pub const B460800 = @as(c_int, 0o010004); +pub const B500000 = @as(c_int, 0o010005); +pub const B576000 = @as(c_int, 0o010006); +pub const B921600 = @as(c_int, 0o010007); +pub const B1000000 = @as(c_int, 0o010010); +pub const B1152000 = @as(c_int, 0o010011); +pub const B1500000 = @as(c_int, 0o010012); +pub const B2000000 = @as(c_int, 0o010013); +pub const B2500000 = @as(c_int, 0o010014); +pub const B3000000 = @as(c_int, 0o010015); +pub const B3500000 = @as(c_int, 0o010016); +pub const B4000000 = @as(c_int, 0o010017); +pub const __MAX_BAUD = B4000000; +pub const CSIZE = @as(c_int, 0o000060); +pub const CS5 = @as(c_int, 0o000000); +pub const CS6 = @as(c_int, 0o000020); +pub const CS7 = @as(c_int, 0o000040); +pub const CS8 = @as(c_int, 0o000060); +pub const CSTOPB = @as(c_int, 0o000100); +pub const CREAD = @as(c_int, 0o000200); +pub const PARENB = @as(c_int, 0o000400); +pub const PARODD = @as(c_int, 0o001000); +pub const HUPCL = @as(c_int, 0o002000); +pub const CLOCAL = @as(c_int, 0o004000); +pub const ADDRB = @import("std").zig.c_translation.promoteIntLiteral(c_int, 0o4000000000, .octal); +pub const ISIG = @as(c_int, 0o000001); +pub const ICANON = @as(c_int, 0o000002); +pub const XCASE = @as(c_int, 0o000004); +pub const ECHO = @as(c_int, 0o000010); +pub const ECHOE = @as(c_int, 0o000020); +pub const ECHOK = @as(c_int, 0o000040); +pub const ECHONL = @as(c_int, 0o000100); +pub const NOFLSH = @as(c_int, 0o000200); +pub const TOSTOP = @as(c_int, 0o000400); +pub const ECHOCTL = @as(c_int, 0o001000); +pub const ECHOPRT = @as(c_int, 0o002000); +pub const ECHOKE = @as(c_int, 0o004000); +pub const FLUSHO = @as(c_int, 0o010000); +pub const PENDIN = @as(c_int, 0o040000); +pub const IEXTEN = @import("std").zig.c_translation.promoteIntLiteral(c_int, 0o100000, .octal); +pub const EXTPROC = @import("std").zig.c_translation.promoteIntLiteral(c_int, 0o200000, .octal); +pub const TIOCSER_TEMT = @as(c_int, 0x01); +pub const TCOOFF = @as(c_int, 0); +pub const TCOON = @as(c_int, 1); +pub const TCIOFF = @as(c_int, 2); +pub const TCION = @as(c_int, 3); +pub const TCIFLUSH = @as(c_int, 0); +pub const TCOFLUSH = @as(c_int, 1); +pub const TCIOFLUSH = @as(c_int, 2); +pub const TCSANOW = @as(c_int, 0); +pub const TCSADRAIN = @as(c_int, 1); +pub const TCSAFLUSH = @as(c_int, 2); +pub inline fn CCEQ(val: anytype, c: anytype) @TypeOf((c == val) and (val != _POSIX_VDISABLE)) { + return (c == val) and (val != _POSIX_VDISABLE); +} +pub const _SYS_TTYDEFAULTS_H_ = ""; +pub const TTYDEF_IFLAG = ((((BRKINT | ISTRIP) | ICRNL) | IMAXBEL) | IXON) | IXANY; +pub const TTYDEF_OFLAG = (OPOST | ONLCR) | XTABS; +pub const TTYDEF_LFLAG = (((((ECHO | ICANON) | ISIG) | IEXTEN) | ECHOE) | ECHOKE) | ECHOCTL; +pub const TTYDEF_CFLAG = ((CREAD | CS7) | PARENB) | HUPCL; +pub const TTYDEF_SPEED = B9600; +pub inline fn CTRL(x: anytype) @TypeOf(x & @as(c_int, 0o37)) { + return x & @as(c_int, 0o37); +} +pub const CEOF = CTRL('d'); +pub const CEOL = _POSIX_VDISABLE; +pub const CERASE = @as(c_int, 0o177); +pub const CINTR = CTRL('c'); +pub const CSTATUS = _POSIX_VDISABLE; +pub const CKILL = CTRL('u'); +pub const CMIN = @as(c_int, 1); +pub const CQUIT = @as(c_int, 0o34); +pub const CSUSP = CTRL('z'); +pub const CTIME = @as(c_int, 0); +pub const CDSUSP = CTRL('y'); +pub const CSTART = CTRL('q'); +pub const CSTOP = CTRL('s'); +pub const CLNEXT = CTRL('v'); +pub const CDISCARD = CTRL('o'); +pub const CWERASE = CTRL('w'); +pub const CREPRINT = CTRL('r'); +pub const CEOT = CEOF; +pub const CBRK = CEOL; +pub const CRPRNT = CREPRINT; +pub const CFLUSH = CDISCARD; +pub const TEMP_FILE_PATH_MAXLEN = @as(c_int, 256); +pub const SPECIAL_WILDCHAR = "`'{"; +pub const ENV_SEPCHAR = ':'; +pub const ENV_SEPSTR = ":"; +pub const BACKSLASH_IN_FILENAME_BOOL = @"false"; +pub const BASENAMELEN = NAME_MAX - @as(c_int, 5); +pub const DEFAULT_MAXPATHL = @as(c_int, 4096); +pub const MAXPATHL = DEFAULT_MAXPATHL; +pub const CMDBUFFSIZE = @as(c_int, 1024); +pub const os_strerror = uv_strerror; +pub const os_translate_sys_error = uv_translate_sys_error; +pub const os_strtok = strtok_r; +pub inline fn kv_A(v: anytype, i: anytype) @TypeOf(v.items[@intCast(usize, i)]) { + return v.items[@intCast(usize, i)]; +} +pub inline fn kv_size(v: anytype) @TypeOf(v.size) { + return v.size; +} +pub inline fn kv_max(v: anytype) @TypeOf(v.capacity) { + return v.capacity; +} +pub inline fn kv_Z(v: anytype, i: anytype) @TypeOf(kv_A(v, (kv_size(v) - i) - @as(c_int, 1))) { + return kv_A(v, (kv_size(v) - i) - @as(c_int, 1)); +} +pub inline fn kv_last(v: anytype) @TypeOf(kv_Z(v, @as(c_int, 0))) { + return kv_Z(v, @as(c_int, 0)); +} +pub inline fn kv_resize_full(v: anytype) @TypeOf(kv_resize(v, if (v.capacity) v.capacity << @as(c_int, 1) else @as(c_int, 8))) { + return kv_resize(v, if (v.capacity) v.capacity << @as(c_int, 1) else @as(c_int, 8)); +} +pub inline fn kv_concat(v: anytype, str: anytype) @TypeOf(kv_concat_len(v, str, strlen(str))) { + return kv_concat_len(v, str, strlen(str)); +} +pub inline fn kv_splice(v1: anytype, v0: anytype) @TypeOf(kv_concat_len(v1, v0.items, v0.size)) { + return kv_concat_len(v1, v0.items, v0.size); +} +pub inline fn kvi_resize_full(v: anytype) @TypeOf(kvi_resize(v, v.capacity << @as(c_int, 1))) { + return kvi_resize(v, v.capacity << @as(c_int, 1)); +} +pub const NVIM_TYPES_H = ""; +pub const ARRAY_DICT_INIT = KV_INITIAL_VALUE; +pub const ERROR_INIT = @import("std").mem.zeroInit(Error, .{ + .type = kErrorTypeNone, + .msg = NULL, +}); +pub inline fn ERROR_SET(e: anytype) @TypeOf(e.*.type != kErrorTypeNone) { + return e.*.type != kErrorTypeNone; +} +pub const INTERNAL_CALL_MASK = @import("std").zig.c_translation.cast(u64, @as(c_int, 1)) << ((@import("std").zig.c_translation.sizeof(u64) * @as(c_int, 8)) - @as(c_int, 1)); +pub const VIML_INTERNAL_CALL = INTERNAL_CALL_MASK; +pub const LUA_INTERNAL_CALL = VIML_INTERNAL_CALL + @as(c_int, 1); +pub const API_INTEGER_MAX = INT64_MAX; +pub const API_INTEGER_MIN = INT64_MIN; +pub const NVIM_API_BUFFER_H = ""; +pub const lauxlib_h = ""; +pub const luaconf_h = ""; +pub const LUAI_IS32INT = (UINT_MAX >> @as(c_int, 30)) >= @as(c_int, 3); +pub const LUA_INT_INT = @as(c_int, 1); +pub const LUA_INT_LONG = @as(c_int, 2); +pub const LUA_INT_LONGLONG = @as(c_int, 3); +pub const LUA_FLOAT_FLOAT = @as(c_int, 1); +pub const LUA_FLOAT_DOUBLE = @as(c_int, 2); +pub const LUA_FLOAT_LONGDOUBLE = @as(c_int, 3); +pub const LUA_INT_DEFAULT = LUA_INT_LONGLONG; +pub const LUA_FLOAT_DEFAULT = LUA_FLOAT_DOUBLE; +pub const LUA_32BITS = @as(c_int, 0); +pub const LUA_C89_NUMBERS = @as(c_int, 0); +pub const LUA_INT_TYPE = LUA_INT_DEFAULT; +pub const LUA_FLOAT_TYPE = LUA_FLOAT_DEFAULT; +pub const LUA_PATH_SEP = ";"; +pub const LUA_PATH_MARK = "?"; +pub const LUA_EXEC_DIR = "!"; +pub const LUA_VDIR = LUA_VERSION_MAJOR ++ "." ++ LUA_VERSION_MINOR; +pub const LUA_ROOT = "/usr/"; +pub const LUA_LDIR = LUA_ROOT ++ "share/lua/" ++ LUA_VDIR ++ "/"; +pub const LUA_CDIR = LUA_ROOT ++ "lib/lua/" ++ LUA_VDIR ++ "/"; +pub const LUA_PATH_DEFAULT = LUA_LDIR ++ "?.lua;" ++ LUA_LDIR ++ "?/init.lua;" ++ LUA_CDIR ++ "?.lua;" ++ LUA_CDIR ++ "?/init.lua;" ++ "./?.lua;" ++ "./?/init.lua"; +pub const LUA_CPATH_DEFAULT = LUA_CDIR ++ "?.so;" ++ LUA_CDIR ++ "loadall.so;" ++ "./?.so"; +pub const LUA_DIRSEP = "/"; +pub const LUALIB_API = LUA_API; +pub const LUAMOD_API = LUA_API; +pub inline fn LUAI_DDEC(dec_1: anytype) @TypeOf(LUAI_FUNC ++ dec_1) { + return LUAI_FUNC ++ dec_1; +} +pub const LUAI_DDEF = ""; +pub inline fn lua_number2str(s: anytype, sz: anytype, n: anytype) @TypeOf(l_sprintf(s, sz, LUA_NUMBER_FMT, LUAI_UACNUMBER(n))) { + return l_sprintf(s, sz, LUA_NUMBER_FMT, LUAI_UACNUMBER(n)); +} +pub const LUA_NUMBER = f64; +pub const LUAI_UACNUMBER = f64; +pub const LUA_NUMBER_FRMLEN = ""; +pub const LUA_NUMBER_FMT = "%.14g"; +pub inline fn l_mathop(op: anytype) @TypeOf(op) { + return op; +} +pub inline fn lua_str2number(s: anytype, p: anytype) @TypeOf(strtod(s, p)) { + return strtod(s, p); +} +pub const LUA_INTEGER_FMT = "%" ++ LUA_INTEGER_FRMLEN ++ "d"; +pub const LUAI_UACINT = LUA_INTEGER; +pub inline fn lua_integer2str(s: anytype, sz: anytype, n: anytype) @TypeOf(l_sprintf(s, sz, LUA_INTEGER_FMT, LUAI_UACINT(n))) { + return l_sprintf(s, sz, LUA_INTEGER_FMT, LUAI_UACINT(n)); +} +pub const LUA_UNSIGNED = c_uint ++ LUAI_UACINT; +pub const LUA_INTEGER = c_longlong; +pub const LUA_INTEGER_FRMLEN = "ll"; +pub const LUA_MAXINTEGER = LLONG_MAX; +pub const LUA_MININTEGER = LLONG_MIN; +pub const LUA_MAXUNSIGNED = ULLONG_MAX; +pub inline fn l_sprintf(s: anytype, sz: anytype, f: anytype, i: anytype) @TypeOf(snprintf(s, sz, f, i)) { + return snprintf(s, sz, f, i); +} +pub inline fn lua_strx2number(s: anytype, p: anytype) @TypeOf(lua_str2number(s, p)) { + return lua_str2number(s, p); +} +pub inline fn lua_pointer2str(buff: anytype, sz: anytype, p: anytype) @TypeOf(l_sprintf(buff, sz, "%p", p)) { + return l_sprintf(buff, sz, "%p", p); +} +pub inline fn lua_number2strx(L: anytype, b: anytype, sz: anytype, f: anytype, n: anytype) @TypeOf(l_sprintf(b, sz, f, LUAI_UACNUMBER(n))) { + return blk_1: { + _ = @import("std").zig.c_translation.cast(anyopaque, L); + break :blk_1 l_sprintf(b, sz, f, LUAI_UACNUMBER(n)); + }; +} +pub const LUA_KCONTEXT = ptrdiff_t; +pub inline fn luai_likely(x: anytype) @TypeOf(__builtin_expect(x != @as(c_int, 0), @as(c_int, 1))) { + return __builtin_expect(x != @as(c_int, 0), @as(c_int, 1)); +} +pub inline fn luai_unlikely(x: anytype) @TypeOf(__builtin_expect(x != @as(c_int, 0), @as(c_int, 0))) { + return __builtin_expect(x != @as(c_int, 0), @as(c_int, 0)); +} +pub const LUAI_MAXSTACK = @import("std").zig.c_translation.promoteIntLiteral(c_int, 1000000, .decimal); +pub const LUA_EXTRASPACE = @import("std").zig.c_translation.sizeof(?*anyopaque); +pub const LUA_IDSIZE = @as(c_int, 60); +pub const LUAL_BUFFERSIZE = @import("std").zig.c_translation.cast(c_int, (@as(c_int, 16) * @import("std").zig.c_translation.sizeof(?*anyopaque)) * @import("std").zig.c_translation.sizeof(lua_Number)); +pub const lua_h = ""; +pub const __STDARG_H = ""; +pub const _VA_LIST = ""; +pub const LUA_VERSION_MAJOR = "5"; +pub const LUA_VERSION_MINOR = "4"; +pub const LUA_VERSION_RELEASE = "4"; +pub const LUA_VERSION_NUM = @as(c_int, 504); +pub const LUA_VERSION_RELEASE_NUM = (LUA_VERSION_NUM * @as(c_int, 100)) + @as(c_int, 4); +pub const LUA_VERSION = "Lua " ++ LUA_VERSION_MAJOR ++ "." ++ LUA_VERSION_MINOR; +pub const LUA_RELEASE = LUA_VERSION ++ "." ++ LUA_VERSION_RELEASE; +pub const LUA_COPYRIGHT = LUA_RELEASE ++ " Copyright (C) 1994-2022 Lua.org, PUC-Rio"; +pub const LUA_AUTHORS = "R. Ierusalimschy, L. H. de Figueiredo, W. Celes"; +pub const LUA_SIGNATURE = "\x1bLua"; +pub const LUA_MULTRET = -@as(c_int, 1); +pub const LUA_REGISTRYINDEX = -LUAI_MAXSTACK - @as(c_int, 1000); +pub inline fn lua_upvalueindex(i: anytype) @TypeOf(LUA_REGISTRYINDEX - i) { + return LUA_REGISTRYINDEX - i; +} +pub const LUA_OK = @as(c_int, 0); +pub const LUA_YIELD = @as(c_int, 1); +pub const LUA_ERRRUN = @as(c_int, 2); +pub const LUA_ERRSYNTAX = @as(c_int, 3); +pub const LUA_ERRMEM = @as(c_int, 4); +pub const LUA_ERRERR = @as(c_int, 5); +pub const LUA_TNONE = -@as(c_int, 1); +pub const LUA_TNIL = @as(c_int, 0); +pub const LUA_TBOOLEAN = @as(c_int, 1); +pub const LUA_TLIGHTUSERDATA = @as(c_int, 2); +pub const LUA_TNUMBER = @as(c_int, 3); +pub const LUA_TSTRING = @as(c_int, 4); +pub const LUA_TTABLE = @as(c_int, 5); +pub const LUA_TFUNCTION = @as(c_int, 6); +pub const LUA_TUSERDATA = @as(c_int, 7); +pub const LUA_TTHREAD = @as(c_int, 8); +pub const LUA_NUMTYPES = @as(c_int, 9); +pub const LUA_MINSTACK = @as(c_int, 20); +pub const LUA_RIDX_MAINTHREAD = @as(c_int, 1); +pub const LUA_RIDX_GLOBALS = @as(c_int, 2); +pub const LUA_RIDX_LAST = LUA_RIDX_GLOBALS; +pub const LUA_OPADD = @as(c_int, 0); +pub const LUA_OPSUB = @as(c_int, 1); +pub const LUA_OPMUL = @as(c_int, 2); +pub const LUA_OPMOD = @as(c_int, 3); +pub const LUA_OPPOW = @as(c_int, 4); +pub const LUA_OPDIV = @as(c_int, 5); +pub const LUA_OPIDIV = @as(c_int, 6); +pub const LUA_OPBAND = @as(c_int, 7); +pub const LUA_OPBOR = @as(c_int, 8); +pub const LUA_OPBXOR = @as(c_int, 9); +pub const LUA_OPSHL = @as(c_int, 10); +pub const LUA_OPSHR = @as(c_int, 11); +pub const LUA_OPUNM = @as(c_int, 12); +pub const LUA_OPBNOT = @as(c_int, 13); +pub const LUA_OPEQ = @as(c_int, 0); +pub const LUA_OPLT = @as(c_int, 1); +pub const LUA_OPLE = @as(c_int, 2); +pub inline fn lua_call(L: anytype, n: anytype, r: anytype) @TypeOf(lua_callk(L, n, r, @as(c_int, 0), NULL)) { + return lua_callk(L, n, r, @as(c_int, 0), NULL); +} +pub inline fn lua_pcall(L: anytype, n: anytype, r: anytype, f: anytype) @TypeOf(lua_pcallk(L, n, r, f, @as(c_int, 0), NULL)) { + return lua_pcallk(L, n, r, f, @as(c_int, 0), NULL); +} +pub inline fn lua_yield(L: anytype, n: anytype) @TypeOf(lua_yieldk(L, n, @as(c_int, 0), NULL)) { + return lua_yieldk(L, n, @as(c_int, 0), NULL); +} +pub const LUA_GCSTOP = @as(c_int, 0); +pub const LUA_GCRESTART = @as(c_int, 1); +pub const LUA_GCCOLLECT = @as(c_int, 2); +pub const LUA_GCCOUNT = @as(c_int, 3); +pub const LUA_GCCOUNTB = @as(c_int, 4); +pub const LUA_GCSTEP = @as(c_int, 5); +pub const LUA_GCSETPAUSE = @as(c_int, 6); +pub const LUA_GCSETSTEPMUL = @as(c_int, 7); +pub const LUA_GCISRUNNING = @as(c_int, 9); +pub const LUA_GCGEN = @as(c_int, 10); +pub const LUA_GCINC = @as(c_int, 11); +pub inline fn lua_getextraspace(L: anytype) ?*anyopaque { + return @import("std").zig.c_translation.cast(?*anyopaque, @import("std").zig.c_translation.cast([*c]u8, L) - LUA_EXTRASPACE); +} +pub inline fn lua_tonumber(L: anytype, i: anytype) @TypeOf(lua_tonumberx(L, i, NULL)) { + return lua_tonumberx(L, i, NULL); +} +pub inline fn lua_tointeger(L: anytype, i: anytype) @TypeOf(lua_tointegerx(L, i, NULL)) { + return lua_tointegerx(L, i, NULL); +} +pub inline fn lua_pop(L: anytype, n: anytype) @TypeOf(lua_settop(L, -n - @as(c_int, 1))) { + return lua_settop(L, -n - @as(c_int, 1)); +} +pub inline fn lua_newtable(L: anytype) @TypeOf(lua_createtable(L, @as(c_int, 0), @as(c_int, 0))) { + return lua_createtable(L, @as(c_int, 0), @as(c_int, 0)); +} +pub inline fn lua_register(L: anytype, n: anytype, f: anytype) @TypeOf(lua_setglobal(L, n)) { + return blk_1: { + _ = lua_pushcfunction(L, f); + break :blk_1 lua_setglobal(L, n); + }; +} +pub inline fn lua_pushcfunction(L: anytype, f: anytype) @TypeOf(lua_pushcclosure(L, f, @as(c_int, 0))) { + return lua_pushcclosure(L, f, @as(c_int, 0)); +} +pub inline fn lua_isfunction(L: anytype, n: anytype) @TypeOf(lua_type(L, n) == LUA_TFUNCTION) { + return lua_type(L, n) == LUA_TFUNCTION; +} +pub inline fn lua_istable(L: anytype, n: anytype) @TypeOf(lua_type(L, n) == LUA_TTABLE) { + return lua_type(L, n) == LUA_TTABLE; +} +pub inline fn lua_islightuserdata(L: anytype, n: anytype) @TypeOf(lua_type(L, n) == LUA_TLIGHTUSERDATA) { + return lua_type(L, n) == LUA_TLIGHTUSERDATA; +} +pub inline fn lua_isnil(L: anytype, n: anytype) @TypeOf(lua_type(L, n) == LUA_TNIL) { + return lua_type(L, n) == LUA_TNIL; +} +pub inline fn lua_isboolean(L: anytype, n: anytype) @TypeOf(lua_type(L, n) == LUA_TBOOLEAN) { + return lua_type(L, n) == LUA_TBOOLEAN; +} +pub inline fn lua_isthread(L: anytype, n: anytype) @TypeOf(lua_type(L, n) == LUA_TTHREAD) { + return lua_type(L, n) == LUA_TTHREAD; +} +pub inline fn lua_isnone(L: anytype, n: anytype) @TypeOf(lua_type(L, n) == LUA_TNONE) { + return lua_type(L, n) == LUA_TNONE; +} +pub inline fn lua_isnoneornil(L: anytype, n: anytype) @TypeOf(lua_type(L, n) <= @as(c_int, 0)) { + return lua_type(L, n) <= @as(c_int, 0); +} +pub inline fn lua_pushliteral(L: anytype, s: anytype) @TypeOf(lua_pushstring(L, "" ++ s)) { + return lua_pushstring(L, "" ++ s); +} +pub inline fn lua_pushglobaltable(L: anytype) anyopaque { + return @import("std").zig.c_translation.cast(anyopaque, lua_rawgeti(L, LUA_REGISTRYINDEX, LUA_RIDX_GLOBALS)); +} +pub inline fn lua_tostring(L: anytype, i: anytype) @TypeOf(lua_tolstring(L, i, NULL)) { + return lua_tolstring(L, i, NULL); +} +pub inline fn lua_insert(L: anytype, idx: anytype) @TypeOf(lua_rotate(L, idx, @as(c_int, 1))) { + return lua_rotate(L, idx, @as(c_int, 1)); +} +pub inline fn lua_remove(L: anytype, idx: anytype) @TypeOf(lua_pop(L, @as(c_int, 1))) { + return blk_1: { + _ = lua_rotate(L, idx, -@as(c_int, 1)); + break :blk_1 lua_pop(L, @as(c_int, 1)); + }; +} +pub inline fn lua_replace(L: anytype, idx: anytype) @TypeOf(lua_pop(L, @as(c_int, 1))) { + return blk_1: { + _ = lua_copy(L, -@as(c_int, 1), idx); + break :blk_1 lua_pop(L, @as(c_int, 1)); + }; +} +pub inline fn lua_newuserdata(L: anytype, s: anytype) @TypeOf(lua_newuserdatauv(L, s, @as(c_int, 1))) { + return lua_newuserdatauv(L, s, @as(c_int, 1)); +} +pub inline fn lua_getuservalue(L: anytype, idx: anytype) @TypeOf(lua_getiuservalue(L, idx, @as(c_int, 1))) { + return lua_getiuservalue(L, idx, @as(c_int, 1)); +} +pub inline fn lua_setuservalue(L: anytype, idx: anytype) @TypeOf(lua_setiuservalue(L, idx, @as(c_int, 1))) { + return lua_setiuservalue(L, idx, @as(c_int, 1)); +} +pub const LUA_NUMTAGS = LUA_NUMTYPES; +pub const LUA_HOOKCALL = @as(c_int, 0); +pub const LUA_HOOKRET = @as(c_int, 1); +pub const LUA_HOOKLINE = @as(c_int, 2); +pub const LUA_HOOKCOUNT = @as(c_int, 3); +pub const LUA_HOOKTAILCALL = @as(c_int, 4); +pub const LUA_MASKCALL = @as(c_int, 1) << LUA_HOOKCALL; +pub const LUA_MASKRET = @as(c_int, 1) << LUA_HOOKRET; +pub const LUA_MASKLINE = @as(c_int, 1) << LUA_HOOKLINE; +pub const LUA_MASKCOUNT = @as(c_int, 1) << LUA_HOOKCOUNT; +pub const LUA_GNAME = "_G"; +pub const LUA_ERRFILE = LUA_ERRERR + @as(c_int, 1); +pub const LUA_LOADED_TABLE = "_LOADED"; +pub const LUA_PRELOAD_TABLE = "_PRELOAD"; +pub const LUAL_NUMSIZES = (@import("std").zig.c_translation.sizeof(lua_Integer) * @as(c_int, 16)) + @import("std").zig.c_translation.sizeof(lua_Number); +pub inline fn luaL_checkversion(L: anytype) @TypeOf(luaL_checkversion_(L, LUA_VERSION_NUM, LUAL_NUMSIZES)) { + return luaL_checkversion_(L, LUA_VERSION_NUM, LUAL_NUMSIZES); +} +pub const LUA_NOREF = -@as(c_int, 2); +pub const LUA_REFNIL = -@as(c_int, 1); +pub inline fn luaL_loadfile(L: anytype, f: anytype) @TypeOf(luaL_loadfilex(L, f, NULL)) { + return luaL_loadfilex(L, f, NULL); +} +pub inline fn luaL_newlib(L: anytype, l: anytype) @TypeOf(luaL_setfuncs(L, l, @as(c_int, 0))) { + return blk_1: { + _ = luaL_checkversion(L); + _ = luaL_newlibtable(L, l); + break :blk_1 luaL_setfuncs(L, l, @as(c_int, 0)); + }; +} +pub inline fn luaL_argcheck(L: anytype, cond: anytype, arg: anytype, extramsg: anytype) anyopaque { + return @import("std").zig.c_translation.cast(anyopaque, (luai_likely(cond) != 0) or (luaL_argerror(L, arg, extramsg) != 0)); +} +pub inline fn luaL_argexpected(L: anytype, cond: anytype, arg: anytype, tname: anytype) anyopaque { + return @import("std").zig.c_translation.cast(anyopaque, (luai_likely(cond) != 0) or (luaL_typeerror(L, arg, tname) != 0)); +} +pub inline fn luaL_checkstring(L: anytype, n: anytype) @TypeOf(luaL_checklstring(L, n, NULL)) { + return luaL_checklstring(L, n, NULL); +} +pub inline fn luaL_optstring(L: anytype, n: anytype, d: anytype) @TypeOf(luaL_optlstring(L, n, d, NULL)) { + return luaL_optlstring(L, n, d, NULL); +} +pub inline fn luaL_typename(L: anytype, i: anytype) @TypeOf(lua_typename(L, lua_type(L, i))) { + return lua_typename(L, lua_type(L, i)); +} +pub inline fn luaL_dofile(L: anytype, @"fn": anytype) @TypeOf((luaL_loadfile(L, @"fn") != 0) or (lua_pcall(L, @as(c_int, 0), LUA_MULTRET, @as(c_int, 0)) != 0)) { + return (luaL_loadfile(L, @"fn") != 0) or (lua_pcall(L, @as(c_int, 0), LUA_MULTRET, @as(c_int, 0)) != 0); +} +pub inline fn luaL_dostring(L: anytype, s: anytype) @TypeOf((luaL_loadstring(L, s) != 0) or (lua_pcall(L, @as(c_int, 0), LUA_MULTRET, @as(c_int, 0)) != 0)) { + return (luaL_loadstring(L, s) != 0) or (lua_pcall(L, @as(c_int, 0), LUA_MULTRET, @as(c_int, 0)) != 0); +} +pub inline fn luaL_getmetatable(L: anytype, n: anytype) @TypeOf(lua_getfield(L, LUA_REGISTRYINDEX, n)) { + return lua_getfield(L, LUA_REGISTRYINDEX, n); +} +pub inline fn luaL_opt(L: anytype, f: anytype, n: anytype, d: anytype) @TypeOf(if (lua_isnoneornil(L, n)) d else f(L, n)) { + return if (lua_isnoneornil(L, n)) d else f(L, n); +} +pub inline fn luaL_loadbuffer(L: anytype, s: anytype, sz: anytype, n: anytype) @TypeOf(luaL_loadbufferx(L, s, sz, n, NULL)) { + return luaL_loadbufferx(L, s, sz, n, NULL); +} +pub inline fn luaL_intop(op: anytype, v1: anytype, v2: anytype) lua_Integer { + return @import("std").zig.c_translation.cast(lua_Integer, @import("std").zig.c_translation.cast(lua_Unsigned, (v1 ++ op)(lua_Unsigned)(v2))); +} +pub inline fn luaL_pushfail(L: anytype) @TypeOf(lua_pushnil(L)) { + return lua_pushnil(L); +} +pub inline fn lua_assert(c: anytype) anyopaque { + _ = @TypeOf(c); + return @import("std").zig.c_translation.cast(anyopaque, @as(c_int, 0)); +} +pub inline fn luaL_bufflen(bf: anytype) @TypeOf(bf.*.n) { + return bf.*.n; +} +pub inline fn luaL_buffaddr(bf: anytype) @TypeOf(bf.*.b) { + return bf.*.b; +} +pub inline fn luaL_prepbuffer(B: anytype) @TypeOf(luaL_prepbuffsize(B, LUAL_BUFFERSIZE)) { + return luaL_prepbuffsize(B, LUAL_BUFFERSIZE); +} +pub const LUA_FILEHANDLE = "FILE*"; +pub inline fn lua_writestring(s: anytype, l: anytype) @TypeOf(fwrite(s, @import("std").zig.c_translation.sizeof(u8), l, stdout)) { + return fwrite(s, @import("std").zig.c_translation.sizeof(u8), l, stdout); +} +pub inline fn lua_writeline() @TypeOf(fflush(stdout)) { + return blk_1: { + _ = lua_writestring("\n", @as(c_int, 1)); + break :blk_1 fflush(stdout); + }; +} +pub inline fn lua_writestringerror(s: anytype, p: anytype) @TypeOf(fflush(stderr)) { + return blk_1: { + _ = fprintf(stderr, s, p); + break :blk_1 fflush(stderr); + }; +} +pub const NVIM_BUFFER_DEFS_H = ""; +pub const NVIM_EVAL_TYPVAL_H = ""; +pub const _ASSERT_H = @as(c_int, 1); +pub const NVIM_EVAL_TYPVAL_DEFS_H = ""; +pub const __CLANG_INTTYPES_H = ""; +pub const _INTTYPES_H = @as(c_int, 1); +pub const ____gwchar_t_defined = @as(c_int, 1); +pub const __PRI64_PREFIX = "l"; +pub const __PRIPTR_PREFIX = "l"; +pub const PRId8 = "d"; +pub const PRId16 = "d"; +pub const PRId32 = "d"; +pub const PRId64 = __PRI64_PREFIX ++ "d"; +pub const PRIdLEAST8 = "d"; +pub const PRIdLEAST16 = "d"; +pub const PRIdLEAST32 = "d"; +pub const PRIdLEAST64 = __PRI64_PREFIX ++ "d"; +pub const PRIdFAST8 = "d"; +pub const PRIdFAST16 = __PRIPTR_PREFIX ++ "d"; +pub const PRIdFAST32 = __PRIPTR_PREFIX ++ "d"; +pub const PRIdFAST64 = __PRI64_PREFIX ++ "d"; +pub const PRIi8 = "i"; +pub const PRIi16 = "i"; +pub const PRIi32 = "i"; +pub const PRIi64 = __PRI64_PREFIX ++ "i"; +pub const PRIiLEAST8 = "i"; +pub const PRIiLEAST16 = "i"; +pub const PRIiLEAST32 = "i"; +pub const PRIiLEAST64 = __PRI64_PREFIX ++ "i"; +pub const PRIiFAST8 = "i"; +pub const PRIiFAST16 = __PRIPTR_PREFIX ++ "i"; +pub const PRIiFAST32 = __PRIPTR_PREFIX ++ "i"; +pub const PRIiFAST64 = __PRI64_PREFIX ++ "i"; +pub const PRIo8 = "o"; +pub const PRIo16 = "o"; +pub const PRIo32 = "o"; +pub const PRIo64 = __PRI64_PREFIX ++ "o"; +pub const PRIoLEAST8 = "o"; +pub const PRIoLEAST16 = "o"; +pub const PRIoLEAST32 = "o"; +pub const PRIoLEAST64 = __PRI64_PREFIX ++ "o"; +pub const PRIoFAST8 = "o"; +pub const PRIoFAST16 = __PRIPTR_PREFIX ++ "o"; +pub const PRIoFAST32 = __PRIPTR_PREFIX ++ "o"; +pub const PRIoFAST64 = __PRI64_PREFIX ++ "o"; +pub const PRIu8 = "u"; +pub const PRIu16 = "u"; +pub const PRIu32 = "u"; +pub const PRIu64 = __PRI64_PREFIX ++ "u"; +pub const PRIuLEAST8 = "u"; +pub const PRIuLEAST16 = "u"; +pub const PRIuLEAST32 = "u"; +pub const PRIuLEAST64 = __PRI64_PREFIX ++ "u"; +pub const PRIuFAST8 = "u"; +pub const PRIuFAST16 = __PRIPTR_PREFIX ++ "u"; +pub const PRIuFAST32 = __PRIPTR_PREFIX ++ "u"; +pub const PRIuFAST64 = __PRI64_PREFIX ++ "u"; +pub const PRIx8 = "x"; +pub const PRIx16 = "x"; +pub const PRIx32 = "x"; +pub const PRIx64 = __PRI64_PREFIX ++ "x"; +pub const PRIxLEAST8 = "x"; +pub const PRIxLEAST16 = "x"; +pub const PRIxLEAST32 = "x"; +pub const PRIxLEAST64 = __PRI64_PREFIX ++ "x"; +pub const PRIxFAST8 = "x"; +pub const PRIxFAST16 = __PRIPTR_PREFIX ++ "x"; +pub const PRIxFAST32 = __PRIPTR_PREFIX ++ "x"; +pub const PRIxFAST64 = __PRI64_PREFIX ++ "x"; +pub const PRIX8 = "X"; +pub const PRIX16 = "X"; +pub const PRIX32 = "X"; +pub const PRIX64 = __PRI64_PREFIX ++ "X"; +pub const PRIXLEAST8 = "X"; +pub const PRIXLEAST16 = "X"; +pub const PRIXLEAST32 = "X"; +pub const PRIXLEAST64 = __PRI64_PREFIX ++ "X"; +pub const PRIXFAST8 = "X"; +pub const PRIXFAST16 = __PRIPTR_PREFIX ++ "X"; +pub const PRIXFAST32 = __PRIPTR_PREFIX ++ "X"; +pub const PRIXFAST64 = __PRI64_PREFIX ++ "X"; +pub const PRIdMAX = __PRI64_PREFIX ++ "d"; +pub const PRIiMAX = __PRI64_PREFIX ++ "i"; +pub const PRIoMAX = __PRI64_PREFIX ++ "o"; +pub const PRIuMAX = __PRI64_PREFIX ++ "u"; +pub const PRIxMAX = __PRI64_PREFIX ++ "x"; +pub const PRIXMAX = __PRI64_PREFIX ++ "X"; +pub const PRIdPTR = __PRIPTR_PREFIX ++ "d"; +pub const PRIiPTR = __PRIPTR_PREFIX ++ "i"; +pub const PRIoPTR = __PRIPTR_PREFIX ++ "o"; +pub const PRIuPTR = __PRIPTR_PREFIX ++ "u"; +pub const PRIxPTR = __PRIPTR_PREFIX ++ "x"; +pub const PRIXPTR = __PRIPTR_PREFIX ++ "X"; +pub const SCNd8 = "hhd"; +pub const SCNd16 = "hd"; +pub const SCNd32 = "d"; +pub const SCNd64 = __PRI64_PREFIX ++ "d"; +pub const SCNdLEAST8 = "hhd"; +pub const SCNdLEAST16 = "hd"; +pub const SCNdLEAST32 = "d"; +pub const SCNdLEAST64 = __PRI64_PREFIX ++ "d"; +pub const SCNdFAST8 = "hhd"; +pub const SCNdFAST16 = __PRIPTR_PREFIX ++ "d"; +pub const SCNdFAST32 = __PRIPTR_PREFIX ++ "d"; +pub const SCNdFAST64 = __PRI64_PREFIX ++ "d"; +pub const SCNi8 = "hhi"; +pub const SCNi16 = "hi"; +pub const SCNi32 = "i"; +pub const SCNi64 = __PRI64_PREFIX ++ "i"; +pub const SCNiLEAST8 = "hhi"; +pub const SCNiLEAST16 = "hi"; +pub const SCNiLEAST32 = "i"; +pub const SCNiLEAST64 = __PRI64_PREFIX ++ "i"; +pub const SCNiFAST8 = "hhi"; +pub const SCNiFAST16 = __PRIPTR_PREFIX ++ "i"; +pub const SCNiFAST32 = __PRIPTR_PREFIX ++ "i"; +pub const SCNiFAST64 = __PRI64_PREFIX ++ "i"; +pub const SCNu8 = "hhu"; +pub const SCNu16 = "hu"; +pub const SCNu32 = "u"; +pub const SCNu64 = __PRI64_PREFIX ++ "u"; +pub const SCNuLEAST8 = "hhu"; +pub const SCNuLEAST16 = "hu"; +pub const SCNuLEAST32 = "u"; +pub const SCNuLEAST64 = __PRI64_PREFIX ++ "u"; +pub const SCNuFAST8 = "hhu"; +pub const SCNuFAST16 = __PRIPTR_PREFIX ++ "u"; +pub const SCNuFAST32 = __PRIPTR_PREFIX ++ "u"; +pub const SCNuFAST64 = __PRI64_PREFIX ++ "u"; +pub const SCNo8 = "hho"; +pub const SCNo16 = "ho"; +pub const SCNo32 = "o"; +pub const SCNo64 = __PRI64_PREFIX ++ "o"; +pub const SCNoLEAST8 = "hho"; +pub const SCNoLEAST16 = "ho"; +pub const SCNoLEAST32 = "o"; +pub const SCNoLEAST64 = __PRI64_PREFIX ++ "o"; +pub const SCNoFAST8 = "hho"; +pub const SCNoFAST16 = __PRIPTR_PREFIX ++ "o"; +pub const SCNoFAST32 = __PRIPTR_PREFIX ++ "o"; +pub const SCNoFAST64 = __PRI64_PREFIX ++ "o"; +pub const SCNx8 = "hhx"; +pub const SCNx16 = "hx"; +pub const SCNx32 = "x"; +pub const SCNx64 = __PRI64_PREFIX ++ "x"; +pub const SCNxLEAST8 = "hhx"; +pub const SCNxLEAST16 = "hx"; +pub const SCNxLEAST32 = "x"; +pub const SCNxLEAST64 = __PRI64_PREFIX ++ "x"; +pub const SCNxFAST8 = "hhx"; +pub const SCNxFAST16 = __PRIPTR_PREFIX ++ "x"; +pub const SCNxFAST32 = __PRIPTR_PREFIX ++ "x"; +pub const SCNxFAST64 = __PRI64_PREFIX ++ "x"; +pub const SCNdMAX = __PRI64_PREFIX ++ "d"; +pub const SCNiMAX = __PRI64_PREFIX ++ "i"; +pub const SCNoMAX = __PRI64_PREFIX ++ "o"; +pub const SCNuMAX = __PRI64_PREFIX ++ "u"; +pub const SCNxMAX = __PRI64_PREFIX ++ "x"; +pub const SCNdPTR = __PRIPTR_PREFIX ++ "d"; +pub const SCNiPTR = __PRIPTR_PREFIX ++ "i"; +pub const SCNoPTR = __PRIPTR_PREFIX ++ "o"; +pub const SCNuPTR = __PRIPTR_PREFIX ++ "u"; +pub const SCNxPTR = __PRIPTR_PREFIX ++ "x"; +pub const NVIM_GARRAY_H = ""; +pub const NVIM_LOG_H = ""; +pub const _SYS_SDT_H = @as(c_int, 1); +pub inline fn _SDT_ARG_CONSTRAINT_STRING(x: anytype) @TypeOf(_SDT_STRINGIFY(x)) { + return _SDT_STRINGIFY(x); +} +pub inline fn _SDT_ASM_STRING(x: anytype) @TypeOf(_SDT_ASM_STRING_1(x)) { + return _SDT_ASM_STRING_1(x); +} +pub inline fn _SDT_ARGSIZE(x: anytype) @TypeOf(if (_SDT_ARGARRAY(x)) @import("std").zig.c_translation.sizeof(?*anyopaque) else @import("std").zig.c_translation.sizeof(x)) { + return if (_SDT_ARGARRAY(x)) @import("std").zig.c_translation.sizeof(?*anyopaque) else @import("std").zig.c_translation.sizeof(x); +} +pub inline fn _SDT_ARGVAL(x: anytype) @TypeOf(x) { + return x; +} +pub const _SDT_NOTE_NAME = "stapsdt"; +pub const _SDT_NOTE_TYPE = @as(c_int, 3); +pub const _SDT_ASM_SECTION_AUTOGROUP_SUPPORT = @as(c_int, 1); +pub const _SDT_ASM_AUTOGROUP = "?"; +pub const _SDT_ASM_TEMPLATE_0 = ""; +pub const _SDT_ASM_TEMPLATE_1 = _SDT_ARGFMT(@as(c_int, 1)); +pub const _SDT_ASM_TEMPLATE_2 = (_SDT_ASM_TEMPLATE_1 ++ _SDT_ARGFMT)(@as(c_int, 2)); +pub const _SDT_ASM_TEMPLATE_3 = (_SDT_ASM_TEMPLATE_2 ++ _SDT_ARGFMT)(@as(c_int, 3)); +pub const _SDT_ASM_TEMPLATE_4 = (_SDT_ASM_TEMPLATE_3 ++ _SDT_ARGFMT)(@as(c_int, 4)); +pub const _SDT_ASM_TEMPLATE_5 = (_SDT_ASM_TEMPLATE_4 ++ _SDT_ARGFMT)(@as(c_int, 5)); +pub const _SDT_ASM_TEMPLATE_6 = (_SDT_ASM_TEMPLATE_5 ++ _SDT_ARGFMT)(@as(c_int, 6)); +pub const _SDT_ASM_TEMPLATE_7 = (_SDT_ASM_TEMPLATE_6 ++ _SDT_ARGFMT)(@as(c_int, 7)); +pub const _SDT_ASM_TEMPLATE_8 = (_SDT_ASM_TEMPLATE_7 ++ _SDT_ARGFMT)(@as(c_int, 8)); +pub const _SDT_ASM_TEMPLATE_9 = (_SDT_ASM_TEMPLATE_8 ++ _SDT_ARGFMT)(@as(c_int, 9)); +pub const _SDT_ASM_TEMPLATE_10 = (_SDT_ASM_TEMPLATE_9 ++ _SDT_ARGFMT)(@as(c_int, 10)); +pub const _SDT_ASM_TEMPLATE_11 = (_SDT_ASM_TEMPLATE_10 ++ _SDT_ARGFMT)(@as(c_int, 11)); +pub const _SDT_ASM_TEMPLATE_12 = (_SDT_ASM_TEMPLATE_11 ++ _SDT_ARGFMT)(@as(c_int, 12)); +pub inline fn _SDT_ASM_OPERANDS_1(arg1: anytype) @TypeOf(_SDT_ARG(@as(c_int, 1), arg1)) { + return _SDT_ARG(@as(c_int, 1), arg1); +} +pub inline fn _SDT_ASM_OPERANDS_2(arg1: anytype, arg2: anytype) @TypeOf(_SDT_ARG(@as(c_int, 2), arg2)) { + return blk: { + _ = _SDT_ASM_OPERANDS_1(arg1); + break :blk _SDT_ARG(@as(c_int, 2), arg2); + }; +} +pub inline fn _SDT_ASM_OPERANDS_3(arg1: anytype, arg2: anytype, arg3: anytype) @TypeOf(_SDT_ARG(@as(c_int, 3), arg3)) { + return blk: { + _ = _SDT_ASM_OPERANDS_2(arg1, arg2); + break :blk _SDT_ARG(@as(c_int, 3), arg3); + }; +} +pub inline fn _SDT_ASM_OPERANDS_4(arg1: anytype, arg2: anytype, arg3: anytype, arg4: anytype) @TypeOf(_SDT_ARG(@as(c_int, 4), arg4)) { + return blk: { + _ = _SDT_ASM_OPERANDS_3(arg1, arg2, arg3); + break :blk _SDT_ARG(@as(c_int, 4), arg4); + }; +} +pub inline fn _SDT_ASM_OPERANDS_5(arg1: anytype, arg2: anytype, arg3: anytype, arg4: anytype, arg5: anytype) @TypeOf(_SDT_ARG(@as(c_int, 5), arg5)) { + return blk: { + _ = _SDT_ASM_OPERANDS_4(arg1, arg2, arg3, arg4); + break :blk _SDT_ARG(@as(c_int, 5), arg5); + }; +} +pub inline fn _SDT_ASM_OPERANDS_6(arg1: anytype, arg2: anytype, arg3: anytype, arg4: anytype, arg5: anytype, arg6: anytype) @TypeOf(_SDT_ARG(@as(c_int, 6), arg6)) { + return blk: { + _ = _SDT_ASM_OPERANDS_5(arg1, arg2, arg3, arg4, arg5); + break :blk _SDT_ARG(@as(c_int, 6), arg6); + }; +} +pub inline fn _SDT_ASM_OPERANDS_7(arg1: anytype, arg2: anytype, arg3: anytype, arg4: anytype, arg5: anytype, arg6: anytype, arg7: anytype) @TypeOf(_SDT_ARG(@as(c_int, 7), arg7)) { + return blk: { + _ = _SDT_ASM_OPERANDS_6(arg1, arg2, arg3, arg4, arg5, arg6); + break :blk _SDT_ARG(@as(c_int, 7), arg7); + }; +} +pub inline fn _SDT_ASM_OPERANDS_8(arg1: anytype, arg2: anytype, arg3: anytype, arg4: anytype, arg5: anytype, arg6: anytype, arg7: anytype, arg8: anytype) @TypeOf(_SDT_ARG(@as(c_int, 8), arg8)) { + return blk: { + _ = _SDT_ASM_OPERANDS_7(arg1, arg2, arg3, arg4, arg5, arg6, arg7); + break :blk _SDT_ARG(@as(c_int, 8), arg8); + }; +} +pub inline fn _SDT_ASM_OPERANDS_9(arg1: anytype, arg2: anytype, arg3: anytype, arg4: anytype, arg5: anytype, arg6: anytype, arg7: anytype, arg8: anytype, arg9: anytype) @TypeOf(_SDT_ARG(@as(c_int, 9), arg9)) { + return blk: { + _ = _SDT_ASM_OPERANDS_8(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8); + break :blk _SDT_ARG(@as(c_int, 9), arg9); + }; +} +pub inline fn _SDT_ASM_OPERANDS_10(arg1: anytype, arg2: anytype, arg3: anytype, arg4: anytype, arg5: anytype, arg6: anytype, arg7: anytype, arg8: anytype, arg9: anytype, arg10: anytype) @TypeOf(_SDT_ARG(@as(c_int, 10), arg10)) { + return blk: { + _ = _SDT_ASM_OPERANDS_9(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9); + break :blk _SDT_ARG(@as(c_int, 10), arg10); + }; +} +pub inline fn _SDT_ASM_OPERANDS_11(arg1: anytype, arg2: anytype, arg3: anytype, arg4: anytype, arg5: anytype, arg6: anytype, arg7: anytype, arg8: anytype, arg9: anytype, arg10: anytype, arg11: anytype) @TypeOf(_SDT_ARG(@as(c_int, 11), arg11)) { + return blk: { + _ = _SDT_ASM_OPERANDS_10(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10); + break :blk _SDT_ARG(@as(c_int, 11), arg11); + }; +} +pub inline fn _SDT_ASM_OPERANDS_12(arg1: anytype, arg2: anytype, arg3: anytype, arg4: anytype, arg5: anytype, arg6: anytype, arg7: anytype, arg8: anytype, arg9: anytype, arg10: anytype, arg11: anytype, arg12: anytype) @TypeOf(_SDT_ARG(@as(c_int, 12), arg12)) { + return blk: { + _ = _SDT_ASM_OPERANDS_11(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11); + break :blk _SDT_ARG(@as(c_int, 12), arg12); + }; +} +pub inline fn STAP_PROBE1(provider: anytype, name: anytype, arg1: anytype) @TypeOf(_SDT_PROBE(provider, name, @as(c_int, 1), arg1)) { + return _SDT_PROBE(provider, name, @as(c_int, 1), arg1); +} +pub inline fn STAP_PROBE2(provider: anytype, name: anytype, arg1: anytype, arg2: anytype) @TypeOf(_SDT_PROBE(provider, name, @as(c_int, 2), blk_1: { + _ = @TypeOf(arg1); + break :blk_1 arg2; +})) { + return _SDT_PROBE(provider, name, @as(c_int, 2), blk_1: { + _ = @TypeOf(arg1); + break :blk_1 arg2; + }); +} +pub inline fn STAP_PROBE3(provider: anytype, name: anytype, arg1: anytype, arg2: anytype, arg3: anytype) @TypeOf(_SDT_PROBE(provider, name, @as(c_int, 3), blk_1: { + _ = @TypeOf(arg1); + _ = @TypeOf(arg2); + break :blk_1 arg3; +})) { + return _SDT_PROBE(provider, name, @as(c_int, 3), blk_1: { + _ = @TypeOf(arg1); + _ = @TypeOf(arg2); + break :blk_1 arg3; + }); +} +pub inline fn STAP_PROBE4(provider: anytype, name: anytype, arg1: anytype, arg2: anytype, arg3: anytype, arg4: anytype) @TypeOf(_SDT_PROBE(provider, name, @as(c_int, 4), blk_1: { + _ = @TypeOf(arg1); + _ = @TypeOf(arg2); + _ = @TypeOf(arg3); + break :blk_1 arg4; +})) { + return _SDT_PROBE(provider, name, @as(c_int, 4), blk_1: { + _ = @TypeOf(arg1); + _ = @TypeOf(arg2); + _ = @TypeOf(arg3); + break :blk_1 arg4; + }); +} +pub inline fn STAP_PROBE5(provider: anytype, name: anytype, arg1: anytype, arg2: anytype, arg3: anytype, arg4: anytype, arg5: anytype) @TypeOf(_SDT_PROBE(provider, name, @as(c_int, 5), blk_1: { + _ = @TypeOf(arg1); + _ = @TypeOf(arg2); + _ = @TypeOf(arg3); + _ = @TypeOf(arg4); + break :blk_1 arg5; +})) { + return _SDT_PROBE(provider, name, @as(c_int, 5), blk_1: { + _ = @TypeOf(arg1); + _ = @TypeOf(arg2); + _ = @TypeOf(arg3); + _ = @TypeOf(arg4); + break :blk_1 arg5; + }); +} +pub inline fn STAP_PROBE6(provider: anytype, name: anytype, arg1: anytype, arg2: anytype, arg3: anytype, arg4: anytype, arg5: anytype, arg6: anytype) @TypeOf(_SDT_PROBE(provider, name, @as(c_int, 6), blk_1: { + _ = @TypeOf(arg1); + _ = @TypeOf(arg2); + _ = @TypeOf(arg3); + _ = @TypeOf(arg4); + _ = @TypeOf(arg5); + break :blk_1 arg6; +})) { + return _SDT_PROBE(provider, name, @as(c_int, 6), blk_1: { + _ = @TypeOf(arg1); + _ = @TypeOf(arg2); + _ = @TypeOf(arg3); + _ = @TypeOf(arg4); + _ = @TypeOf(arg5); + break :blk_1 arg6; + }); +} +pub inline fn STAP_PROBE7(provider: anytype, name: anytype, arg1: anytype, arg2: anytype, arg3: anytype, arg4: anytype, arg5: anytype, arg6: anytype, arg7: anytype) @TypeOf(_SDT_PROBE(provider, name, @as(c_int, 7), blk_1: { + _ = @TypeOf(arg1); + _ = @TypeOf(arg2); + _ = @TypeOf(arg3); + _ = @TypeOf(arg4); + _ = @TypeOf(arg5); + _ = @TypeOf(arg6); + break :blk_1 arg7; +})) { + return _SDT_PROBE(provider, name, @as(c_int, 7), blk_1: { + _ = @TypeOf(arg1); + _ = @TypeOf(arg2); + _ = @TypeOf(arg3); + _ = @TypeOf(arg4); + _ = @TypeOf(arg5); + _ = @TypeOf(arg6); + break :blk_1 arg7; + }); +} +pub inline fn STAP_PROBE8(provider: anytype, name: anytype, arg1: anytype, arg2: anytype, arg3: anytype, arg4: anytype, arg5: anytype, arg6: anytype, arg7: anytype, arg8: anytype) @TypeOf(_SDT_PROBE(provider, name, @as(c_int, 8), blk_1: { + _ = @TypeOf(arg1); + _ = @TypeOf(arg2); + _ = @TypeOf(arg3); + _ = @TypeOf(arg4); + _ = @TypeOf(arg5); + _ = @TypeOf(arg6); + _ = @TypeOf(arg7); + break :blk_1 arg8; +})) { + return _SDT_PROBE(provider, name, @as(c_int, 8), blk_1: { + _ = @TypeOf(arg1); + _ = @TypeOf(arg2); + _ = @TypeOf(arg3); + _ = @TypeOf(arg4); + _ = @TypeOf(arg5); + _ = @TypeOf(arg6); + _ = @TypeOf(arg7); + break :blk_1 arg8; + }); +} +pub inline fn STAP_PROBE9(provider: anytype, name: anytype, arg1: anytype, arg2: anytype, arg3: anytype, arg4: anytype, arg5: anytype, arg6: anytype, arg7: anytype, arg8: anytype, arg9: anytype) @TypeOf(_SDT_PROBE(provider, name, @as(c_int, 9), blk_1: { + _ = @TypeOf(arg1); + _ = @TypeOf(arg2); + _ = @TypeOf(arg3); + _ = @TypeOf(arg4); + _ = @TypeOf(arg5); + _ = @TypeOf(arg6); + _ = @TypeOf(arg7); + _ = @TypeOf(arg8); + break :blk_1 arg9; +})) { + return _SDT_PROBE(provider, name, @as(c_int, 9), blk_1: { + _ = @TypeOf(arg1); + _ = @TypeOf(arg2); + _ = @TypeOf(arg3); + _ = @TypeOf(arg4); + _ = @TypeOf(arg5); + _ = @TypeOf(arg6); + _ = @TypeOf(arg7); + _ = @TypeOf(arg8); + break :blk_1 arg9; + }); +} +pub inline fn STAP_PROBE10(provider: anytype, name: anytype, arg1: anytype, arg2: anytype, arg3: anytype, arg4: anytype, arg5: anytype, arg6: anytype, arg7: anytype, arg8: anytype, arg9: anytype, arg10: anytype) @TypeOf(_SDT_PROBE(provider, name, @as(c_int, 10), blk_1: { + _ = @TypeOf(arg1); + _ = @TypeOf(arg2); + _ = @TypeOf(arg3); + _ = @TypeOf(arg4); + _ = @TypeOf(arg5); + _ = @TypeOf(arg6); + _ = @TypeOf(arg7); + _ = @TypeOf(arg8); + _ = @TypeOf(arg9); + break :blk_1 arg10; +})) { + return _SDT_PROBE(provider, name, @as(c_int, 10), blk_1: { + _ = @TypeOf(arg1); + _ = @TypeOf(arg2); + _ = @TypeOf(arg3); + _ = @TypeOf(arg4); + _ = @TypeOf(arg5); + _ = @TypeOf(arg6); + _ = @TypeOf(arg7); + _ = @TypeOf(arg8); + _ = @TypeOf(arg9); + break :blk_1 arg10; + }); +} +pub inline fn STAP_PROBE11(provider: anytype, name: anytype, arg1: anytype, arg2: anytype, arg3: anytype, arg4: anytype, arg5: anytype, arg6: anytype, arg7: anytype, arg8: anytype, arg9: anytype, arg10: anytype, arg11: anytype) @TypeOf(_SDT_PROBE(provider, name, @as(c_int, 11), blk_1: { + _ = @TypeOf(arg1); + _ = @TypeOf(arg2); + _ = @TypeOf(arg3); + _ = @TypeOf(arg4); + _ = @TypeOf(arg5); + _ = @TypeOf(arg6); + _ = @TypeOf(arg7); + _ = @TypeOf(arg8); + _ = @TypeOf(arg9); + _ = @TypeOf(arg10); + break :blk_1 arg11; +})) { + return _SDT_PROBE(provider, name, @as(c_int, 11), blk_1: { + _ = @TypeOf(arg1); + _ = @TypeOf(arg2); + _ = @TypeOf(arg3); + _ = @TypeOf(arg4); + _ = @TypeOf(arg5); + _ = @TypeOf(arg6); + _ = @TypeOf(arg7); + _ = @TypeOf(arg8); + _ = @TypeOf(arg9); + _ = @TypeOf(arg10); + break :blk_1 arg11; + }); +} +pub inline fn STAP_PROBE12(provider: anytype, name: anytype, arg1: anytype, arg2: anytype, arg3: anytype, arg4: anytype, arg5: anytype, arg6: anytype, arg7: anytype, arg8: anytype, arg9: anytype, arg10: anytype, arg11: anytype, arg12: anytype) @TypeOf(_SDT_PROBE(provider, name, @as(c_int, 12), blk_1: { + _ = @TypeOf(arg1); + _ = @TypeOf(arg2); + _ = @TypeOf(arg3); + _ = @TypeOf(arg4); + _ = @TypeOf(arg5); + _ = @TypeOf(arg6); + _ = @TypeOf(arg7); + _ = @TypeOf(arg8); + _ = @TypeOf(arg9); + _ = @TypeOf(arg10); + _ = @TypeOf(arg11); + break :blk_1 arg12; +})) { + return _SDT_PROBE(provider, name, @as(c_int, 12), blk_1: { + _ = @TypeOf(arg1); + _ = @TypeOf(arg2); + _ = @TypeOf(arg3); + _ = @TypeOf(arg4); + _ = @TypeOf(arg5); + _ = @TypeOf(arg6); + _ = @TypeOf(arg7); + _ = @TypeOf(arg8); + _ = @TypeOf(arg9); + _ = @TypeOf(arg10); + _ = @TypeOf(arg11); + break :blk_1 arg12; + }); +} +pub inline fn DTRACE_PROBE(provider: anytype, probe: anytype) @TypeOf(STAP_PROBE(provider, probe)) { + return STAP_PROBE(provider, probe); +} +pub inline fn DTRACE_PROBE1(provider: anytype, probe: anytype, parm1: anytype) @TypeOf(STAP_PROBE1(provider, probe, parm1)) { + return STAP_PROBE1(provider, probe, parm1); +} +pub inline fn DTRACE_PROBE2(provider: anytype, probe: anytype, parm1: anytype, parm2: anytype) @TypeOf(STAP_PROBE2(provider, probe, parm1, parm2)) { + return STAP_PROBE2(provider, probe, parm1, parm2); +} +pub inline fn DTRACE_PROBE3(provider: anytype, probe: anytype, parm1: anytype, parm2: anytype, parm3: anytype) @TypeOf(STAP_PROBE3(provider, probe, parm1, parm2, parm3)) { + return STAP_PROBE3(provider, probe, parm1, parm2, parm3); +} +pub inline fn DTRACE_PROBE4(provider: anytype, probe: anytype, parm1: anytype, parm2: anytype, parm3: anytype, parm4: anytype) @TypeOf(STAP_PROBE4(provider, probe, parm1, parm2, parm3, parm4)) { + return STAP_PROBE4(provider, probe, parm1, parm2, parm3, parm4); +} +pub inline fn DTRACE_PROBE5(provider: anytype, probe: anytype, parm1: anytype, parm2: anytype, parm3: anytype, parm4: anytype, parm5: anytype) @TypeOf(STAP_PROBE5(provider, probe, parm1, parm2, parm3, parm4, parm5)) { + return STAP_PROBE5(provider, probe, parm1, parm2, parm3, parm4, parm5); +} +pub inline fn DTRACE_PROBE6(provider: anytype, probe: anytype, parm1: anytype, parm2: anytype, parm3: anytype, parm4: anytype, parm5: anytype, parm6: anytype) @TypeOf(STAP_PROBE6(provider, probe, parm1, parm2, parm3, parm4, parm5, parm6)) { + return STAP_PROBE6(provider, probe, parm1, parm2, parm3, parm4, parm5, parm6); +} +pub inline fn DTRACE_PROBE7(provider: anytype, probe: anytype, parm1: anytype, parm2: anytype, parm3: anytype, parm4: anytype, parm5: anytype, parm6: anytype, parm7: anytype) @TypeOf(STAP_PROBE7(provider, probe, parm1, parm2, parm3, parm4, parm5, parm6, parm7)) { + return STAP_PROBE7(provider, probe, parm1, parm2, parm3, parm4, parm5, parm6, parm7); +} +pub inline fn DTRACE_PROBE8(provider: anytype, probe: anytype, parm1: anytype, parm2: anytype, parm3: anytype, parm4: anytype, parm5: anytype, parm6: anytype, parm7: anytype, parm8: anytype) @TypeOf(STAP_PROBE8(provider, probe, parm1, parm2, parm3, parm4, parm5, parm6, parm7, parm8)) { + return STAP_PROBE8(provider, probe, parm1, parm2, parm3, parm4, parm5, parm6, parm7, parm8); +} +pub inline fn DTRACE_PROBE9(provider: anytype, probe: anytype, parm1: anytype, parm2: anytype, parm3: anytype, parm4: anytype, parm5: anytype, parm6: anytype, parm7: anytype, parm8: anytype, parm9: anytype) @TypeOf(STAP_PROBE9(provider, probe, parm1, parm2, parm3, parm4, parm5, parm6, parm7, parm8, parm9)) { + return STAP_PROBE9(provider, probe, parm1, parm2, parm3, parm4, parm5, parm6, parm7, parm8, parm9); +} +pub inline fn DTRACE_PROBE10(provider: anytype, probe: anytype, parm1: anytype, parm2: anytype, parm3: anytype, parm4: anytype, parm5: anytype, parm6: anytype, parm7: anytype, parm8: anytype, parm9: anytype, parm10: anytype) @TypeOf(STAP_PROBE10(provider, probe, parm1, parm2, parm3, parm4, parm5, parm6, parm7, parm8, parm9, parm10)) { + return STAP_PROBE10(provider, probe, parm1, parm2, parm3, parm4, parm5, parm6, parm7, parm8, parm9, parm10); +} +pub inline fn DTRACE_PROBE11(provider: anytype, probe: anytype, parm1: anytype, parm2: anytype, parm3: anytype, parm4: anytype, parm5: anytype, parm6: anytype, parm7: anytype, parm8: anytype, parm9: anytype, parm10: anytype, parm11: anytype) @TypeOf(STAP_PROBE11(provider, probe, parm1, parm2, parm3, parm4, parm5, parm6, parm7, parm8, parm9, parm10, parm11)) { + return STAP_PROBE11(provider, probe, parm1, parm2, parm3, parm4, parm5, parm6, parm7, parm8, parm9, parm10, parm11); +} +pub inline fn DTRACE_PROBE12(provider: anytype, probe: anytype, parm1: anytype, parm2: anytype, parm3: anytype, parm4: anytype, parm5: anytype, parm6: anytype, parm7: anytype, parm8: anytype, parm9: anytype, parm10: anytype, parm11: anytype, parm12: anytype) @TypeOf(STAP_PROBE12(provider, probe, parm1, parm2, parm3, parm4, parm5, parm6, parm7, parm8, parm9, parm10, parm11, parm12)) { + return STAP_PROBE12(provider, probe, parm1, parm2, parm3, parm4, parm5, parm6, parm7, parm8, parm9, parm10, parm11, parm12); +} +pub const LOGLVL_DBG = @as(c_int, 1); +pub const LOGLVL_INF = @as(c_int, 2); +pub const LOGLVL_WRN = @as(c_int, 3); +pub const LOGLVL_ERR = @as(c_int, 4); +pub inline fn GA_EMPTY(ga_ptr: anytype) @TypeOf(ga_ptr.*.ga_len <= @as(c_int, 0)) { + return ga_ptr.*.ga_len <= @as(c_int, 0); +} +pub inline fn GA_APPEND_VIA_PTR(item_type: anytype, gap: anytype) @TypeOf(ga_append_via_ptr(gap, @import("std").zig.c_translation.sizeof(item_type))) { + _ = @TypeOf(item_type); + return ga_append_via_ptr(gap, @import("std").zig.c_translation.sizeof(item_type)); +} +pub inline fn FREE_PTR_PTR(ptr: anytype) @TypeOf(xfree(ptr.*)) { + return xfree(ptr.*); +} +pub inline fn GA_DEEP_CLEAR_PTR(gap: anytype) @TypeOf(GA_DEEP_CLEAR(gap, ?*anyopaque, FREE_PTR_PTR)) { + return GA_DEEP_CLEAR(gap, ?*anyopaque, FREE_PTR_PTR); +} +pub const NVIM_HASHTAB_H = ""; +pub const HI_KEY_REMOVED = &hash_removed; +pub inline fn HASHITEM_EMPTY(hi: anytype) @TypeOf((hi.*.hi_key == NULL) or (hi.*.hi_key == (&hash_removed))) { + return (hi.*.hi_key == NULL) or (hi.*.hi_key == (&hash_removed)); +} +pub const HT_INIT_SIZE = @as(c_int, 16); +pub const NVIM_LIB_QUEUE_H = ""; +pub inline fn QUEUE_HEAD(q: anytype) @TypeOf(q.*.next) { + return q.*.next; +} +pub const NVIM_POS_H = ""; +pub const PRIdLINENR = PRId32; +pub const PRIdCOLNR = "d"; +pub const VARNUMBER_MAX = INT64_MAX; +pub const UVARNUMBER_MAX = UINT64_MAX; +pub const VARNUMBER_MIN = INT64_MIN; +pub const PRIdVARNUMBER = PRId64; +pub const CALLBACK_NONE = @import("std").zig.c_translation.cast(Callback, CALLBACK_INIT); +pub const PRIdSCID = "d"; +pub const NVIM_GETTEXT_H = ""; +pub const _LIBINTL_H = @as(c_int, 1); +pub const __USE_GNU_GETTEXT = @as(c_int, 1); +pub inline fn __GNU_GETTEXT_SUPPORTED_REVISION(major: anytype) @TypeOf(if (major == @as(c_int, 0)) @as(c_int, 1) else -@as(c_int, 1)) { + return if (major == @as(c_int, 0)) @as(c_int, 1) else -@as(c_int, 1); +} +pub inline fn @"_"(x: anytype) @TypeOf(gettext(x)) { + return gettext(x); +} +pub inline fn N_(x: anytype) @TypeOf(x) { + return x; +} +pub inline fn NGETTEXT(x: anytype, xs: anytype, n: anytype) @TypeOf(ngettext(x, xs, @import("std").zig.c_translation.cast(c_ulong, n))) { + return ngettext(x, xs, @import("std").zig.c_translation.cast(c_ulong, n)); +} +pub const NVIM_MBYTE_DEFS_H = ""; +pub const NVIM_ICONV_H = ""; +pub const _ERRNO_H = @as(c_int, 1); +pub const _BITS_ERRNO_H = @as(c_int, 1); +pub const _ASM_GENERIC_ERRNO_H = ""; +pub const _ASM_GENERIC_ERRNO_BASE_H = ""; +pub const EPERM = @as(c_int, 1); +pub const ENOENT = @as(c_int, 2); +pub const ESRCH = @as(c_int, 3); +pub const EINTR = @as(c_int, 4); +pub const EIO = @as(c_int, 5); +pub const ENXIO = @as(c_int, 6); +pub const E2BIG = @as(c_int, 7); +pub const ENOEXEC = @as(c_int, 8); +pub const EBADF = @as(c_int, 9); +pub const ECHILD = @as(c_int, 10); +pub const EAGAIN = @as(c_int, 11); +pub const ENOMEM = @as(c_int, 12); +pub const EACCES = @as(c_int, 13); +pub const EFAULT = @as(c_int, 14); +pub const ENOTBLK = @as(c_int, 15); +pub const EBUSY = @as(c_int, 16); +pub const EEXIST = @as(c_int, 17); +pub const EXDEV = @as(c_int, 18); +pub const ENODEV = @as(c_int, 19); +pub const ENOTDIR = @as(c_int, 20); +pub const EISDIR = @as(c_int, 21); +pub const EINVAL = @as(c_int, 22); +pub const ENFILE = @as(c_int, 23); +pub const EMFILE = @as(c_int, 24); +pub const ENOTTY = @as(c_int, 25); +pub const ETXTBSY = @as(c_int, 26); +pub const EFBIG = @as(c_int, 27); +pub const ENOSPC = @as(c_int, 28); +pub const ESPIPE = @as(c_int, 29); +pub const EROFS = @as(c_int, 30); +pub const EMLINK = @as(c_int, 31); +pub const EPIPE = @as(c_int, 32); +pub const EDOM = @as(c_int, 33); +pub const ERANGE = @as(c_int, 34); +pub const EDEADLK = @as(c_int, 35); +pub const ENAMETOOLONG = @as(c_int, 36); +pub const ENOLCK = @as(c_int, 37); +pub const ENOSYS = @as(c_int, 38); +pub const ENOTEMPTY = @as(c_int, 39); +pub const ELOOP = @as(c_int, 40); +pub const EWOULDBLOCK = EAGAIN; +pub const ENOMSG = @as(c_int, 42); +pub const EIDRM = @as(c_int, 43); +pub const ECHRNG = @as(c_int, 44); +pub const EL2NSYNC = @as(c_int, 45); +pub const EL3HLT = @as(c_int, 46); +pub const EL3RST = @as(c_int, 47); +pub const ELNRNG = @as(c_int, 48); +pub const EUNATCH = @as(c_int, 49); +pub const ENOCSI = @as(c_int, 50); +pub const EL2HLT = @as(c_int, 51); +pub const EBADE = @as(c_int, 52); +pub const EBADR = @as(c_int, 53); +pub const EXFULL = @as(c_int, 54); +pub const ENOANO = @as(c_int, 55); +pub const EBADRQC = @as(c_int, 56); +pub const EBADSLT = @as(c_int, 57); +pub const EDEADLOCK = EDEADLK; +pub const EBFONT = @as(c_int, 59); +pub const ENOSTR = @as(c_int, 60); +pub const ENODATA = @as(c_int, 61); +pub const ETIME = @as(c_int, 62); +pub const ENOSR = @as(c_int, 63); +pub const ENONET = @as(c_int, 64); +pub const ENOPKG = @as(c_int, 65); +pub const EREMOTE = @as(c_int, 66); +pub const ENOLINK = @as(c_int, 67); +pub const EADV = @as(c_int, 68); +pub const ESRMNT = @as(c_int, 69); +pub const ECOMM = @as(c_int, 70); +pub const EPROTO = @as(c_int, 71); +pub const EMULTIHOP = @as(c_int, 72); +pub const EDOTDOT = @as(c_int, 73); +pub const EBADMSG = @as(c_int, 74); +pub const EOVERFLOW = @as(c_int, 75); +pub const ENOTUNIQ = @as(c_int, 76); +pub const EBADFD = @as(c_int, 77); +pub const EREMCHG = @as(c_int, 78); +pub const ELIBACC = @as(c_int, 79); +pub const ELIBBAD = @as(c_int, 80); +pub const ELIBSCN = @as(c_int, 81); +pub const ELIBMAX = @as(c_int, 82); +pub const ELIBEXEC = @as(c_int, 83); +pub const EILSEQ = @as(c_int, 84); +pub const ERESTART = @as(c_int, 85); +pub const ESTRPIPE = @as(c_int, 86); +pub const EUSERS = @as(c_int, 87); +pub const ENOTSOCK = @as(c_int, 88); +pub const EDESTADDRREQ = @as(c_int, 89); +pub const EMSGSIZE = @as(c_int, 90); +pub const EPROTOTYPE = @as(c_int, 91); +pub const ENOPROTOOPT = @as(c_int, 92); +pub const EPROTONOSUPPORT = @as(c_int, 93); +pub const ESOCKTNOSUPPORT = @as(c_int, 94); +pub const EOPNOTSUPP = @as(c_int, 95); +pub const EPFNOSUPPORT = @as(c_int, 96); +pub const EAFNOSUPPORT = @as(c_int, 97); +pub const EADDRINUSE = @as(c_int, 98); +pub const EADDRNOTAVAIL = @as(c_int, 99); +pub const ENETDOWN = @as(c_int, 100); +pub const ENETUNREACH = @as(c_int, 101); +pub const ENETRESET = @as(c_int, 102); +pub const ECONNABORTED = @as(c_int, 103); +pub const ECONNRESET = @as(c_int, 104); +pub const ENOBUFS = @as(c_int, 105); +pub const EISCONN = @as(c_int, 106); +pub const ENOTCONN = @as(c_int, 107); +pub const ESHUTDOWN = @as(c_int, 108); +pub const ETOOMANYREFS = @as(c_int, 109); +pub const ETIMEDOUT = @as(c_int, 110); +pub const ECONNREFUSED = @as(c_int, 111); +pub const EHOSTDOWN = @as(c_int, 112); +pub const EHOSTUNREACH = @as(c_int, 113); +pub const EALREADY = @as(c_int, 114); +pub const EINPROGRESS = @as(c_int, 115); +pub const ESTALE = @as(c_int, 116); +pub const EUCLEAN = @as(c_int, 117); +pub const ENOTNAM = @as(c_int, 118); +pub const ENAVAIL = @as(c_int, 119); +pub const EISNAM = @as(c_int, 120); +pub const EREMOTEIO = @as(c_int, 121); +pub const EDQUOT = @as(c_int, 122); +pub const ENOMEDIUM = @as(c_int, 123); +pub const EMEDIUMTYPE = @as(c_int, 124); +pub const ECANCELED = @as(c_int, 125); +pub const ENOKEY = @as(c_int, 126); +pub const EKEYEXPIRED = @as(c_int, 127); +pub const EKEYREVOKED = @as(c_int, 128); +pub const EKEYREJECTED = @as(c_int, 129); +pub const EOWNERDEAD = @as(c_int, 130); +pub const ENOTRECOVERABLE = @as(c_int, 131); +pub const ERFKILL = @as(c_int, 132); +pub const EHWPOISON = @as(c_int, 133); +pub const ENOTSUP = EOPNOTSUPP; +pub const errno = __errno_location().*; +pub const _ICONV_H = @as(c_int, 1); +pub const ICONV_ERRNO = errno; +pub const ICONV_E2BIG = E2BIG; +pub const ICONV_EINVAL = EINVAL; +pub const ICONV_EILSEQ = EILSEQ; +pub const NVIM_MESSAGE_H = ""; +pub const NVIM_GRID_DEFS_H = ""; +pub const MAX_MCO = @as(c_int, 6); +pub const VIM_GENERIC = @as(c_int, 0); +pub const VIM_ERROR = @as(c_int, 1); +pub const VIM_WARNING = @as(c_int, 2); +pub const VIM_INFO = @as(c_int, 3); +pub const VIM_QUESTION = @as(c_int, 4); +pub const VIM_LAST_TYPE = @as(c_int, 4); +pub const VIM_YES = @as(c_int, 2); +pub const VIM_NO = @as(c_int, 3); +pub const VIM_CANCEL = @as(c_int, 4); +pub const VIM_ALL = @as(c_int, 5); +pub const VIM_DISCARDALL = @as(c_int, 6); +pub inline fn TV_LIST_ITEM_TV(li: anytype) @TypeOf(&li.*.li_tv) { + return &li.*.li_tv; +} +pub inline fn TV_LIST_ITEM_NEXT(l: anytype, li: anytype) @TypeOf(li.*.li_next) { + _ = @TypeOf(l); + return li.*.li_next; +} +pub inline fn TV_LIST_ITEM_PREV(l: anytype, li: anytype) @TypeOf(li.*.li_prev) { + _ = @TypeOf(l); + return li.*.li_prev; +} +pub const TV_TRANSLATE = SIZE_MAX; +pub const TV_CSTRING = SIZE_MAX - @as(c_int, 1); +pub const tv_get_bool = tv_get_number; +pub const tv_get_bool_chk = tv_get_number_chk; +pub const tv_dict_get_bool = tv_dict_get_number_def; +pub const NVIM_HIGHLIGHT_DEFS_H = ""; +pub const NVIM_MAP_H = ""; +pub const NVIM_LIB_KHASH_H = ""; +pub const AC_VERSION_KHASH_H = "0.2.8"; +pub inline fn __ac_isempty(flag: anytype, i: anytype) @TypeOf((flag[@intCast(usize, i >> @as(c_int, 4))] >> ((i & @as(c_uint, 0xf)) << @as(c_int, 1))) & @as(c_int, 2)) { + return (flag[@intCast(usize, i >> @as(c_int, 4))] >> ((i & @as(c_uint, 0xf)) << @as(c_int, 1))) & @as(c_int, 2); +} +pub inline fn __ac_isdel(flag: anytype, i: anytype) @TypeOf((flag[@intCast(usize, i >> @as(c_int, 4))] >> ((i & @as(c_uint, 0xf)) << @as(c_int, 1))) & @as(c_int, 1)) { + return (flag[@intCast(usize, i >> @as(c_int, 4))] >> ((i & @as(c_uint, 0xf)) << @as(c_int, 1))) & @as(c_int, 1); +} +pub inline fn __ac_iseither(flag: anytype, i: anytype) @TypeOf((flag[@intCast(usize, i >> @as(c_int, 4))] >> ((i & @as(c_uint, 0xf)) << @as(c_int, 1))) & @as(c_int, 3)) { + return (flag[@intCast(usize, i >> @as(c_int, 4))] >> ((i & @as(c_uint, 0xf)) << @as(c_int, 1))) & @as(c_int, 3); +} +pub inline fn __ac_fsize(m: anytype) @TypeOf(if (m < @as(c_int, 16)) @as(c_int, 1) else m >> @as(c_int, 4)) { + return if (m < @as(c_int, 16)) @as(c_int, 1) else m >> @as(c_int, 4); +} +pub inline fn kcalloc(N: anytype, Z: anytype) @TypeOf(xcalloc(N, Z)) { + return xcalloc(N, Z); +} +pub inline fn kmalloc(Z: anytype) @TypeOf(xmalloc(Z)) { + return xmalloc(Z); +} +pub inline fn krealloc(P: anytype, Z: anytype) @TypeOf(xrealloc(P, Z)) { + return xrealloc(P, Z); +} +pub inline fn kfree(P: anytype) @TypeOf(XFREE_CLEAR(P)) { + return XFREE_CLEAR(P); +} +pub const __ac_HASH_UPPER = @as(f64, 0.77); +pub inline fn kh_int_hash_func(key: anytype) khint32_t { + return @import("std").zig.c_translation.cast(khint32_t, key); +} +pub inline fn kh_int_hash_equal(a: anytype, b: anytype) @TypeOf(a == b) { + return a == b; +} +pub inline fn kh_int64_hash_func(key: anytype) khint32_t { + return @import("std").zig.c_translation.cast(khint32_t, ((key >> @as(c_int, 33)) ^ key) ^ (key << @as(c_int, 11))); +} +pub inline fn kh_int64_hash_equal(a: anytype, b: anytype) @TypeOf(a == b) { + return a == b; +} +pub inline fn kh_str_hash_func(key: anytype) @TypeOf(__ac_X31_hash_string(key)) { + return __ac_X31_hash_string(key); +} +pub inline fn kh_str_hash_equal(a: anytype, b: anytype) @TypeOf(strcmp(a, b) == @as(c_int, 0)) { + return strcmp(a, b) == @as(c_int, 0); +} +pub inline fn kh_exist(h: anytype, x: anytype) @TypeOf(!(__ac_iseither(h.*.flags, x) != 0)) { + return !(__ac_iseither(h.*.flags, x) != 0); +} +pub inline fn kh_key(h: anytype, x: anytype) @TypeOf(h.*.keys[@intCast(usize, x)]) { + return h.*.keys[@intCast(usize, x)]; +} +pub inline fn kh_val(h: anytype, x: anytype) @TypeOf(h.*.vals[@intCast(usize, x)]) { + return h.*.vals[@intCast(usize, x)]; +} +pub inline fn kh_value(h: anytype, x: anytype) @TypeOf(h.*.vals[@intCast(usize, x)]) { + return h.*.vals[@intCast(usize, x)]; +} +pub inline fn kh_begin(h: anytype) khint_t { + _ = @TypeOf(h); + return @import("std").zig.c_translation.cast(khint_t, @as(c_int, 0)); +} +pub inline fn kh_end(h: anytype) @TypeOf(h.*.n_buckets) { + return h.*.n_buckets; +} +pub inline fn kh_size(h: anytype) @TypeOf(h.*.size) { + return h.*.size; +} +pub inline fn kh_n_buckets(h: anytype) @TypeOf(h.*.n_buckets) { + return h.*.n_buckets; +} +pub inline fn KHASH_SET_INIT_INT(name: anytype) @TypeOf(KHASH_INIT(name, khint32_t, u8, @as(c_int, 0), kh_int_hash_func, kh_int_hash_equal)) { + return KHASH_INIT(name, khint32_t, u8, @as(c_int, 0), kh_int_hash_func, kh_int_hash_equal); +} +pub inline fn KHASH_MAP_INIT_INT(name: anytype, khval_t: anytype) @TypeOf(KHASH_INIT(name, khint32_t, khval_t, @as(c_int, 1), kh_int_hash_func, kh_int_hash_equal)) { + return KHASH_INIT(name, khint32_t, khval_t, @as(c_int, 1), kh_int_hash_func, kh_int_hash_equal); +} +pub inline fn KHASH_SET_INIT_INT64(name: anytype) @TypeOf(KHASH_INIT(name, khint64_t, u8, @as(c_int, 0), kh_int64_hash_func, kh_int64_hash_equal)) { + return KHASH_INIT(name, khint64_t, u8, @as(c_int, 0), kh_int64_hash_func, kh_int64_hash_equal); +} +pub inline fn KHASH_MAP_INIT_INT64(name: anytype, khval_t: anytype) @TypeOf(KHASH_INIT(name, khint64_t, khval_t, @as(c_int, 1), kh_int64_hash_func, kh_int64_hash_equal)) { + return KHASH_INIT(name, khint64_t, khval_t, @as(c_int, 1), kh_int64_hash_func, kh_int64_hash_equal); +} +pub inline fn KHASH_SET_INIT_STR(name: anytype) @TypeOf(KHASH_INIT(name, kh_cstr_t, u8, @as(c_int, 0), kh_str_hash_func, kh_str_hash_equal)) { + return KHASH_INIT(name, kh_cstr_t, u8, @as(c_int, 0), kh_str_hash_func, kh_str_hash_equal); +} +pub inline fn KHASH_MAP_INIT_STR(name: anytype, khval_t: anytype) @TypeOf(KHASH_INIT(name, kh_cstr_t, khval_t, @as(c_int, 1), kh_str_hash_func, kh_str_hash_equal)) { + return KHASH_INIT(name, kh_cstr_t, khval_t, @as(c_int, 1), kh_str_hash_func, kh_str_hash_equal); +} +pub const NVIM_EXTMARK_DEFS_H = ""; +pub const NVIM_MAP_DEFS_H = ""; +pub inline fn PMap(T: anytype) @TypeOf(Map(T, ptr_t)) { + return Map(T, ptr_t); +} +pub const NVIM_TUI_INPUT_DEFS_H = ""; +pub const NVIM_UI_CLIENT_H = ""; +pub const UI_CLIENT_STDIN_FD = @as(c_int, 3); +pub inline fn map_size(map: anytype) @TypeOf(map.*.table.size) { + return map.*.table.size; +} +pub inline fn pmap_destroy(T: anytype) @TypeOf(map_destroy(T, ptr_t)) { + return map_destroy(T, ptr_t); +} +pub inline fn pmap_get(T: anytype) @TypeOf(map_get(T, ptr_t)) { + return map_get(T, ptr_t); +} +pub inline fn pmap_has(T: anytype) @TypeOf(map_has(T, ptr_t)) { + return map_has(T, ptr_t); +} +pub inline fn pmap_key(T: anytype) @TypeOf(map_key(T, ptr_t)) { + return map_key(T, ptr_t); +} +pub inline fn pmap_put(T: anytype) @TypeOf(map_put(T, ptr_t)) { + return map_put(T, ptr_t); +} +pub inline fn pmap_ref(T: anytype) @TypeOf(map_ref(T, ptr_t)) { + return map_ref(T, ptr_t); +} +pub inline fn pmap_del(T: anytype) @TypeOf(map_del(T, ptr_t)) { + return map_del(T, ptr_t); +} +pub inline fn pmap_clear(T: anytype) @TypeOf(map_clear(T, ptr_t)) { + return map_clear(T, ptr_t); +} +pub inline fn pmap_init(k: anytype, map: anytype) @TypeOf(map_init(k, ptr_t, map)) { + return map_init(k, ptr_t, map); +} +pub inline fn map_foreach(map: anytype, key: anytype, value: anytype, block: anytype) @TypeOf(kh_foreach(&map.*.table, key, value, block)) { + return kh_foreach(&map.*.table, key, value, block); +} +pub inline fn map_foreach_value(map: anytype, value: anytype, block: anytype) @TypeOf(kh_foreach_value(&map.*.table, value, block)) { + return kh_foreach_value(&map.*.table, value, block); +} +pub const NVIM_MARK_DEFS_H = ""; +pub const NVIM_OS_TIME_H = ""; +pub const EXTRA_MARKS = ('9' - '0') + @as(c_int, 1); +pub const NMARKS = ('z' - 'a') + @as(c_int, 1); +pub const NGLOBALMARKS = NMARKS + EXTRA_MARKS; +pub const NLOCALMARKS = NMARKS + @as(c_int, 3); +pub const NMARK_LOCAL_MAX = @as(c_int, 126); +pub const JUMPLISTSIZE = @as(c_int, 100); +pub const TAGSTACKSIZE = @as(c_int, 20); +pub const NVIM_MARKTREE_H = ""; +pub const NVIM_ASSERT_H = ""; +pub const STATIC_ASSERT_PRAGMA_START = ""; +pub const STATIC_ASSERT_PRAGMA_END = ""; +pub inline fn ASSERT_CONCAT(a: anytype, b: anytype) @TypeOf(ASSERT_CONCAT_(a, b)) { + return ASSERT_CONCAT_(a, b); +} +pub const MT_MAX_DEPTH = @as(c_int, 20); +pub const MT_BRANCH_FACTOR = @as(c_int, 10); +pub inline fn marktree_itr_valid(itr: anytype) @TypeOf(itr.*.node != NULL) { + return itr.*.node != NULL; +} +pub const MT_FLAG_REAL = @import("std").zig.c_translation.cast(u16, @as(c_int, 1)) << @as(c_int, 0); +pub const MT_FLAG_END = @import("std").zig.c_translation.cast(u16, @as(c_int, 1)) << @as(c_int, 1); +pub const MT_FLAG_PAIRED = @import("std").zig.c_translation.cast(u16, @as(c_int, 1)) << @as(c_int, 2); +pub const MT_FLAG_HL_EOL = @import("std").zig.c_translation.cast(u16, @as(c_int, 1)) << @as(c_int, 3); +pub const DECOR_LEVELS = @as(c_int, 4); +pub const MT_FLAG_DECOR_OFFSET = @as(c_int, 4); +pub const MT_FLAG_DECOR_MASK = @import("std").zig.c_translation.cast(u16, DECOR_LEVELS - @as(c_int, 1)) << MT_FLAG_DECOR_OFFSET; +pub const MT_FLAG_RIGHT_GRAVITY = @import("std").zig.c_translation.cast(u16, @as(c_int, 1)) << @as(c_int, 14); +pub const MT_FLAG_LAST = @import("std").zig.c_translation.cast(u16, @as(c_int, 1)) << @as(c_int, 15); +pub const MT_FLAG_EXTERNAL_MASK = (MT_FLAG_DECOR_MASK | MT_FLAG_RIGHT_GRAVITY) | MT_FLAG_HL_EOL; +pub const MARKTREE_END_FLAG = @import("std").zig.c_translation.cast(u64, @as(c_int, 1)) << @as(c_int, 63); +pub const NVIM_OPTION_DEFS_H = ""; +pub const P_BOOL = @as(c_uint, 0x01); +pub const P_NUM = @as(c_uint, 0x02); +pub const P_STRING = @as(c_uint, 0x04); +pub const P_ALLOCED = @as(c_uint, 0x08); +pub const P_EXPAND = @as(c_uint, 0x10); +pub const P_NODEFAULT = @as(c_uint, 0x40); +pub const P_DEF_ALLOCED = @as(c_uint, 0x80); +pub const P_WAS_SET = @as(c_uint, 0x100); +pub const P_NO_MKRC = @as(c_uint, 0x200); +pub const P_UI_OPTION = @as(c_uint, 0x400); +pub const P_RTABL = @as(c_uint, 0x800); +pub const P_RSTAT = @as(c_uint, 0x1000); +pub const P_RWIN = @as(c_uint, 0x2000); +pub const P_RBUF = @as(c_uint, 0x4000); +pub const P_RALL = @as(c_uint, 0x6000); +pub const P_RCLR = @as(c_uint, 0x7000); +pub const P_COMMA = @as(c_uint, 0x8000); +pub const P_ONECOMMA = @import("std").zig.c_translation.promoteIntLiteral(c_uint, 0x18000, .hexadecimal); +pub const P_NODUP = @import("std").zig.c_translation.promoteIntLiteral(c_uint, 0x20000, .hexadecimal); +pub const P_FLAGLIST = @import("std").zig.c_translation.promoteIntLiteral(c_uint, 0x40000, .hexadecimal); +pub const P_SECURE = @import("std").zig.c_translation.promoteIntLiteral(c_uint, 0x80000, .hexadecimal); +pub const P_GETTEXT = @import("std").zig.c_translation.promoteIntLiteral(c_uint, 0x100000, .hexadecimal); +pub const P_NOGLOB = @import("std").zig.c_translation.promoteIntLiteral(c_uint, 0x200000, .hexadecimal); +pub const P_NFNAME = @import("std").zig.c_translation.promoteIntLiteral(c_uint, 0x400000, .hexadecimal); +pub const P_INSECURE = @import("std").zig.c_translation.promoteIntLiteral(c_uint, 0x800000, .hexadecimal); +pub const P_PRI_MKRC = @import("std").zig.c_translation.promoteIntLiteral(c_uint, 0x1000000, .hexadecimal); +pub const P_NO_ML = @import("std").zig.c_translation.promoteIntLiteral(c_uint, 0x2000000, .hexadecimal); +pub const P_CURSWANT = @import("std").zig.c_translation.promoteIntLiteral(c_uint, 0x4000000, .hexadecimal); +pub const P_NDNAME = @import("std").zig.c_translation.promoteIntLiteral(c_uint, 0x8000000, .hexadecimal); +pub const P_RWINONLY = @import("std").zig.c_translation.promoteIntLiteral(c_uint, 0x10000000, .hexadecimal); +pub const P_MLE = @import("std").zig.c_translation.promoteIntLiteral(c_uint, 0x20000000, .hexadecimal); +pub const P_FUNC = @import("std").zig.c_translation.promoteIntLiteral(c_uint, 0x40000000, .hexadecimal); +pub const P_NO_DEF_EXP = @import("std").zig.c_translation.promoteIntLiteral(c_uint, 0x80000000, .hexadecimal); +pub const SOPT_BOOL = @as(c_int, 0x01); +pub const SOPT_NUM = @as(c_int, 0x02); +pub const SOPT_STRING = @as(c_int, 0x04); +pub const SOPT_GLOBAL = @as(c_int, 0x08); +pub const SOPT_WIN = @as(c_int, 0x10); +pub const SOPT_BUF = @as(c_int, 0x20); +pub const SOPT_UNSET = @as(c_int, 0x40); +pub const SREQ_GLOBAL = @as(c_int, 0); +pub const SREQ_WIN = @as(c_int, 1); +pub const SREQ_BUF = @as(c_int, 2); +pub const HIGHLIGHT_INIT = "8:SpecialKey,~:EndOfBuffer,z:TermCursor,Z:TermCursorNC,@:NonText,d:Directory,e:ErrorMsg," ++ "i:IncSearch,l:Search,y:CurSearch,m:MoreMsg,M:ModeMsg,n:LineNr,a:LineNrAbove,b:LineNrBelow," ++ "N:CursorLineNr,G:CursorLineSign,O:CursorLineFold" ++ "r:Question,s:StatusLine,S:StatusLineNC,c:VertSplit,t:Title,v:Visual,V:VisualNOS,w:WarningMsg," ++ "W:WildMenu,f:Folded,F:FoldColumn,A:DiffAdd,C:DiffChange,D:DiffDelete,T:DiffText,>:SignColumn," ++ "-:Conceal,B:SpellBad,P:SpellCap,R:SpellRare,L:SpellLocal,+:Pmenu,=:PmenuSel," ++ "[:PmenuKind,]:PmenuKindSel,{:PmenuExtra,}:PmenuExtraSel,x:PmenuSbar,X:PmenuThumb," ++ "*:TabLine,#:TabLineSel,_:TabLineFill,!:CursorColumn,.:CursorLine,o:ColorColumn," ++ "q:QuickFixLine,0:Whitespace,I:NormalNC"; +pub const DFLT_EFM = "%*[^\"]\"%f\"%*\\D%l: %m,\"%f\"%*\\D%l: %m,%-G%f:%l: (Each undeclared identifier is reported only once,%-G%f:%l: for each function it appears in.),%-GIn file included from %f:%l:%c:,%-GIn file included from %f:%l:%c\\,,%-GIn file included from %f:%l:%c,%-GIn file included from %f:%l,%-G%*[ ]from %f:%l:%c,%-G%*[ ]from %f:%l:,%-G%*[ ]from %f:%l\\,,%-G%*[ ]from %f:%l,%f:%l:%c:%m,%f(%l):%m,%f:%l:%m,\"%f\"\\, line %l%*\\D%c%*[^ ] %m,%D%*\\a[%*\\d]: Entering directory %*[`']%f',%X%*\\a[%*\\d]: Leaving directory %*[`']%f',%D%*\\a: Entering directory %*[`']%f',%X%*\\a: Leaving directory %*[`']%f',%DMaking %*\\a in %f,%f|%l| %m"; +pub const DFLT_GREPFORMAT = "%f:%l:%m,%f:%l%m,%f %l%m"; +pub const FF_DOS = "dos"; +pub const FF_MAC = "mac"; +pub const FF_UNIX = "unix"; +pub const DFLT_FF = "unix"; +pub const DFLT_FFS_VIM = "unix,dos"; +pub const DFLT_FFS_VI = ""; +pub const ENC_UCSBOM = "ucs-bom"; +pub const ENC_DFLT = "utf-8"; +pub const EOL_UNKNOWN = -@as(c_int, 1); +pub const EOL_UNIX = @as(c_int, 0); +pub const EOL_DOS = @as(c_int, 1); +pub const EOL_MAC = @as(c_int, 2); +pub const FO_WRAP = 't'; +pub const FO_WRAP_COMS = 'c'; +pub const FO_RET_COMS = 'r'; +pub const FO_OPEN_COMS = 'o'; +pub const FO_NO_OPEN_COMS = '/'; +pub const FO_Q_COMS = 'q'; +pub const FO_Q_NUMBER = 'n'; +pub const FO_Q_SECOND = '2'; +pub const FO_INS_VI = 'v'; +pub const FO_INS_LONG = 'l'; +pub const FO_INS_BLANK = 'b'; +pub const FO_MBYTE_BREAK = 'm'; +pub const FO_MBYTE_JOIN = 'M'; +pub const FO_MBYTE_JOIN2 = 'B'; +pub const FO_ONE_LETTER = '1'; +pub const FO_WHITE_PAR = 'w'; +pub const FO_AUTO = 'a'; +pub const FO_RIGOROUS_TW = ']'; +pub const FO_REMOVE_COMS = 'j'; +pub const FO_PERIOD_ABBR = 'p'; +pub const DFLT_FO_VI = "vt"; +pub const DFLT_FO_VIM = "tcqj"; +pub const FO_ALL = "tcro/q2vlb1mMBn,aw]jp"; +pub const CPO_ALTREAD = 'a'; +pub const CPO_ALTWRITE = 'A'; +pub const CPO_BAR = 'b'; +pub const CPO_BSLASH = 'B'; +pub const CPO_SEARCH = 'c'; +pub const CPO_CONCAT = 'C'; +pub const CPO_DOTTAG = 'd'; +pub const CPO_DIGRAPH = 'D'; +pub const CPO_EXECBUF = 'e'; +pub const CPO_EMPTYREGION = 'E'; +pub const CPO_FNAMER = 'f'; +pub const CPO_FNAMEW = 'F'; +pub const CPO_INTMOD = 'i'; +pub const CPO_INDENT = 'I'; +pub const CPO_ENDOFSENT = 'J'; +pub const CPO_KOFFSET = 'K'; +pub const CPO_LITERAL = 'l'; +pub const CPO_LISTWM = 'L'; +pub const CPO_SHOWMATCH = 'm'; +pub const CPO_MATCHBSL = 'M'; +pub const CPO_NUMCOL = 'n'; +pub const CPO_LINEOFF = 'o'; +pub const CPO_OVERNEW = 'O'; +pub const CPO_LISP = 'p'; +pub const CPO_FNAMEAPP = 'P'; +pub const CPO_JOINCOL = 'q'; +pub const CPO_REDO = 'r'; +pub const CPO_REMMARK = 'R'; +pub const CPO_BUFOPT = 's'; +pub const CPO_BUFOPTGLOB = 'S'; +pub const CPO_TAGPAT = 't'; +pub const CPO_UNDO = 'u'; +pub const CPO_BACKSPACE = 'v'; +pub const CPO_FWRITE = 'W'; +pub const CPO_ESC = 'x'; +pub const CPO_REPLCNT = 'X'; +pub const CPO_YANK = 'y'; +pub const CPO_KEEPRO = 'Z'; +pub const CPO_DOLLAR = '$'; +pub const CPO_FILTER = '!'; +pub const CPO_MATCH = '%'; +pub const CPO_PLUS = '+'; +pub const CPO_REGAPPEND = '>'; +pub const CPO_SCOLON = ';'; +pub const CPO_CHANGEW = '_'; +pub const CPO_VIM = "aABceFs_"; +pub const CPO_VI = "aAbBcCdDeEfFiIJKlLmMnoOpPqrRsStuvWxXyZ$!%+>;_"; +pub const WW_ALL = "bshl<>[],~"; +pub const MOUSE_NORMAL = 'n'; +pub const MOUSE_VISUAL = 'v'; +pub const MOUSE_INSERT = 'i'; +pub const MOUSE_COMMAND = 'c'; +pub const MOUSE_HELP = 'h'; +pub const MOUSE_RETURN = 'r'; +pub const MOUSE_A = "nvich"; +pub const MOUSE_ALL = "anvichr"; +pub const MOUSE_NONE = ' '; +pub const MOUSE_NONEF = 'x'; +pub const MOUSESCROLL_VERT_DFLT = @as(c_int, 3); +pub const MOUSESCROLL_HOR_DFLT = @as(c_int, 6); +pub const COCU_ALL = "nvic"; +pub const GO_ASEL = 'a'; +pub const GO_ASELML = 'A'; +pub const GO_BOT = 'b'; +pub const GO_CONDIALOG = 'c'; +pub const GO_DARKTHEME = 'd'; +pub const GO_TABLINE = 'e'; +pub const GO_FORG = 'f'; +pub const GO_GREY = 'g'; +pub const GO_HORSCROLL = 'h'; +pub const GO_ICON = 'i'; +pub const GO_LEFT = 'l'; +pub const GO_VLEFT = 'L'; +pub const GO_MENUS = 'm'; +pub const GO_NOSYSMENU = 'M'; +pub const GO_POINTER = 'p'; +pub const GO_ASELPLUS = 'P'; +pub const GO_RIGHT = 'r'; +pub const GO_VRIGHT = 'R'; +pub const GO_TOOLBAR = 'T'; +pub const GO_FOOTER = 'F'; +pub const GO_VERTICAL = 'v'; +pub const GO_KEEPWINSIZE = 'k'; +pub const GO_ALL = "aAbcdefFghilmMprTvk"; +pub const COM_NEST = 'n'; +pub const COM_BLANK = 'b'; +pub const COM_START = 's'; +pub const COM_MIDDLE = 'm'; +pub const COM_END = 'e'; +pub const COM_AUTO_END = 'x'; +pub const COM_FIRST = 'f'; +pub const COM_LEFT = 'l'; +pub const COM_RIGHT = 'r'; +pub const COM_NOBACK = 'O'; +pub const COM_ALL = "nbsmexflrO"; +pub const COM_MAX_LEN = @as(c_int, 50); +pub const WIM_FULL = @as(c_int, 0x01); +pub const WIM_LONGEST = @as(c_int, 0x02); +pub const WIM_LIST = @as(c_int, 0x04); +pub const WIM_BUFLASTUSED = @as(c_int, 0x08); +pub const BS_INDENT = 'i'; +pub const BS_EOL = 'l'; +pub const BS_START = 's'; +pub const BS_NOSTOP = 'p'; +pub const CULOPT_LINE = @as(c_int, 0x01); +pub const CULOPT_SCRLINE = @as(c_int, 0x02); +pub const CULOPT_NBR = @as(c_int, 0x04); +pub const LISPWORD_VALUE = "defun,define,defmacro,set!,lambda,if,case,let,flet,let*,letrec,do,do*,define-syntax,let-syntax,letrec-syntax,destructuring-bind,defpackage,defparameter,defstruct,deftype,defvar,do-all-symbols,do-external-symbols,do-symbols,dolist,dotimes,ecase,etypecase,eval-when,labels,macrolet,multiple-value-bind,multiple-value-call,multiple-value-prog1,multiple-value-setq,prog1,progv,typecase,unless,unwind-protect,when,with-input-from-string,with-open-file,with-open-stream,with-output-to-string,with-package-iterator,define-condition,handler-bind,handler-case,restart-bind,restart-case,with-simple-restart,store-value,use-value,muffle-warning,abort,continue,with-slots,with-slots*,with-accessors,with-accessors*,defclass,defmethod,print-unreadable-object"; +pub const BKC_YES = @as(c_int, 0x001); +pub const BKC_AUTO = @as(c_int, 0x002); +pub const BKC_NO = @as(c_int, 0x004); +pub const BKC_BREAKSYMLINK = @as(c_int, 0x008); +pub const BKC_BREAKHARDLINK = @as(c_int, 0x010); +pub const BO_ALL = @as(c_int, 0x0001); +pub const BO_BS = @as(c_int, 0x0002); +pub const BO_CRSR = @as(c_int, 0x0004); +pub const BO_COMPL = @as(c_int, 0x0008); +pub const BO_COPY = @as(c_int, 0x0010); +pub const BO_CTRLG = @as(c_int, 0x0020); +pub const BO_ERROR = @as(c_int, 0x0040); +pub const BO_ESC = @as(c_int, 0x0080); +pub const BO_EX = @as(c_int, 0x0100); +pub const BO_HANGUL = @as(c_int, 0x0200); +pub const BO_IM = @as(c_int, 0x0400); +pub const BO_LANG = @as(c_int, 0x0800); +pub const BO_MESS = @as(c_int, 0x1000); +pub const BO_MATCH = @as(c_int, 0x2000); +pub const BO_OPER = @as(c_int, 0x4000); +pub const BO_REG = @import("std").zig.c_translation.promoteIntLiteral(c_int, 0x8000, .hexadecimal); +pub const BO_SH = @import("std").zig.c_translation.promoteIntLiteral(c_int, 0x10000, .hexadecimal); +pub const BO_SPELL = @import("std").zig.c_translation.promoteIntLiteral(c_int, 0x20000, .hexadecimal); +pub const BO_WILD = @import("std").zig.c_translation.promoteIntLiteral(c_int, 0x40000, .hexadecimal); +pub const CMP_INTERNAL = @as(c_int, 0x001); +pub const CMP_KEEPASCII = @as(c_int, 0x002); +pub const CB_UNNAMED = @as(c_int, 0x001); +pub const CB_UNNAMEDPLUS = @as(c_int, 0x002); +pub const CB_UNNAMEDMASK = CB_UNNAMED | CB_UNNAMEDPLUS; +pub const DY_LASTLINE = @as(c_int, 0x001); +pub const DY_TRUNCATE = @as(c_int, 0x002); +pub const DY_UHEX = @as(c_int, 0x004); +pub const DY_MSGSEP = @as(c_int, 0x008); +pub const FDO_ALL = @as(c_int, 0x001); +pub const FDO_BLOCK = @as(c_int, 0x002); +pub const FDO_HOR = @as(c_int, 0x004); +pub const FDO_MARK = @as(c_int, 0x008); +pub const FDO_PERCENT = @as(c_int, 0x010); +pub const FDO_QUICKFIX = @as(c_int, 0x020); +pub const FDO_SEARCH = @as(c_int, 0x040); +pub const FDO_TAG = @as(c_int, 0x080); +pub const FDO_INSERT = @as(c_int, 0x100); +pub const FDO_UNDO = @as(c_int, 0x200); +pub const FDO_JUMP = @as(c_int, 0x400); +pub const JOP_STACK = @as(c_int, 0x01); +pub const JOP_VIEW = @as(c_int, 0x02); +pub const RDB_COMPOSITOR = @as(c_int, 0x001); +pub const RDB_NOTHROTTLE = @as(c_int, 0x002); +pub const RDB_INVALID = @as(c_int, 0x004); +pub const RDB_NODELTA = @as(c_int, 0x008); +pub const RDB_LINE = @as(c_int, 0x010); +pub const RDB_FLUSH = @as(c_int, 0x020); +pub const SSOP_BUFFERS = @as(c_int, 0x001); +pub const SSOP_WINPOS = @as(c_int, 0x002); +pub const SSOP_RESIZE = @as(c_int, 0x004); +pub const SSOP_WINSIZE = @as(c_int, 0x008); +pub const SSOP_LOCALOPTIONS = @as(c_int, 0x010); +pub const SSOP_OPTIONS = @as(c_int, 0x020); +pub const SSOP_HELP = @as(c_int, 0x040); +pub const SSOP_BLANK = @as(c_int, 0x080); +pub const SSOP_GLOBALS = @as(c_int, 0x100); +pub const SSOP_SLASH = @as(c_int, 0x200); +pub const SSOP_UNIX = @as(c_int, 0x400); +pub const SSOP_SESDIR = @as(c_int, 0x800); +pub const SSOP_CURDIR = @as(c_int, 0x1000); +pub const SSOP_FOLDS = @as(c_int, 0x2000); +pub const SSOP_CURSOR = @as(c_int, 0x4000); +pub const SSOP_TABPAGES = @import("std").zig.c_translation.promoteIntLiteral(c_int, 0x8000, .hexadecimal); +pub const SSOP_TERMINAL = @import("std").zig.c_translation.promoteIntLiteral(c_int, 0x10000, .hexadecimal); +pub const SSOP_SKIP_RTP = @import("std").zig.c_translation.promoteIntLiteral(c_int, 0x20000, .hexadecimal); +pub const TPF_BS = @as(c_int, 0x001); +pub const TPF_HT = @as(c_int, 0x002); +pub const TPF_FF = @as(c_int, 0x004); +pub const TPF_ESC = @as(c_int, 0x008); +pub const TPF_DEL = @as(c_int, 0x010); +pub const TPF_C0 = @as(c_int, 0x020); +pub const TPF_C1 = @as(c_int, 0x040); +pub const SWB_USEOPEN = @as(c_int, 0x001); +pub const SWB_USETAB = @as(c_int, 0x002); +pub const SWB_SPLIT = @as(c_int, 0x004); +pub const SWB_NEWTAB = @as(c_int, 0x008); +pub const SWB_VSPLIT = @as(c_int, 0x010); +pub const SWB_USELAST = @as(c_int, 0x020); +pub const TC_FOLLOWIC = @as(c_int, 0x01); +pub const TC_IGNORE = @as(c_int, 0x02); +pub const TC_MATCH = @as(c_int, 0x04); +pub const TC_FOLLOWSCS = @as(c_int, 0x08); +pub const TC_SMART = @as(c_int, 0x10); +pub const VE_BLOCK = @as(c_uint, 5); +pub const VE_INSERT = @as(c_uint, 6); +pub const VE_ALL = @as(c_uint, 4); +pub const VE_ONEMORE = @as(c_uint, 8); +pub const VE_NONE = @as(c_uint, 16); +pub const VE_NONEU = @as(c_uint, 32); +pub const WOP_TAGFILE = @as(c_int, 0x01); +pub const WOP_PUM = @as(c_int, 0x02); +pub const WOP_FUZZY = @as(c_int, 0x04); +pub const NO_LOCAL_UNDOLEVEL = -@import("std").zig.c_translation.promoteIntLiteral(c_int, 123456, .decimal); +pub const SB_MAX = @import("std").zig.c_translation.promoteIntLiteral(c_int, 100000, .decimal); +pub const TABSTOP_MAX = @as(c_int, 9999); +pub const PV_BOTH = @as(c_int, 0x1000); +pub const PV_WIN = @as(c_int, 0x2000); +pub const PV_BUF = @as(c_int, 0x4000); +pub const PV_MASK = @as(c_int, 0x0fff); +pub inline fn OPT_WIN(x: anytype) idopt_T { + return @import("std").zig.c_translation.cast(idopt_T, PV_WIN + @import("std").zig.c_translation.cast(c_int, x)); +} +pub inline fn OPT_BUF(x: anytype) idopt_T { + return @import("std").zig.c_translation.cast(idopt_T, PV_BUF + @import("std").zig.c_translation.cast(c_int, x)); +} +pub inline fn OPT_BOTH(x: anytype) idopt_T { + return @import("std").zig.c_translation.cast(idopt_T, PV_BOTH + @import("std").zig.c_translation.cast(c_int, x)); +} +pub const VAR_WIN = @import("std").zig.c_translation.cast([*c]u8, -@as(c_int, 1)); +pub const NVIM_STATUSLINE_DEFS_H = ""; +pub const NVIM_FOLD_DEFS_H = ""; +pub const NVIM_SIGN_DEFS_H = ""; +pub inline fn HI2SG(hi: anytype) [*c]signgroup_T { + return @import("std").zig.c_translation.cast([*c]signgroup_T, hi.*.hi_key - SGN_KEY_OFF); +} +pub const SIGN_SHOW_MAX = @as(c_int, 9); +pub const SIGN_DEF_PRIO = @as(c_int, 10); +pub const NVIM_UNDO_DEFS_H = ""; +pub const UH_CHANGED = @as(c_int, 0x01); +pub const UH_EMPTYBUF = @as(c_int, 0x02); +pub const UH_RELOAD = @as(c_int, 0x04); +pub inline fn GETFILE_SUCCESS(x: anytype) @TypeOf(x <= @as(c_int, 0)) { + return x <= @as(c_int, 0); +} +pub inline fn MODIFIABLE(buf: anytype) @TypeOf(buf.*.b_p_ma) { + return buf.*.b_p_ma; +} +pub const VALID_WROW = @as(c_int, 0x01); +pub const VALID_WCOL = @as(c_int, 0x02); +pub const VALID_VIRTCOL = @as(c_int, 0x04); +pub const VALID_CHEIGHT = @as(c_int, 0x08); +pub const VALID_CROW = @as(c_int, 0x10); +pub const VALID_BOTLINE = @as(c_int, 0x20); +pub const VALID_BOTLINE_AP = @as(c_int, 0x40); +pub const VALID_TOPLINE = @as(c_int, 0x80); +pub const BF_RECOVERED = @as(c_int, 0x01); +pub const BF_CHECK_RO = @as(c_int, 0x02); +pub const BF_NEVERLOADED = @as(c_int, 0x04); +pub const BF_NOTEDITED = @as(c_int, 0x08); +pub const BF_NEW = @as(c_int, 0x10); +pub const BF_NEW_W = @as(c_int, 0x20); +pub const BF_READERR = @as(c_int, 0x40); +pub const BF_DUMMY = @as(c_int, 0x80); +pub const BF_SYN_SET = @as(c_int, 0x200); +pub const BF_WRITE_MASK = (BF_NOTEDITED + BF_NEW) + BF_READERR; +pub const NVIM_MEMLINE_DEFS_H = ""; +pub const NVIM_MEMFILE_DEFS_H = ""; +pub const MHT_INIT_SIZE = @as(c_int, 64); +pub const BH_DIRTY = @as(c_uint, 1); +pub const BH_LOCKED = @as(c_uint, 2); +pub const ML_CHNK_ADDLINE = @as(c_int, 1); +pub const ML_CHNK_DELLINE = @as(c_int, 2); +pub const ML_CHNK_UPDLINE = @as(c_int, 3); +pub const ML_EMPTY = @as(c_int, 0x01); +pub const ML_LINE_DIRTY = @as(c_int, 0x02); +pub const ML_LOCKED_DIRTY = @as(c_int, 0x04); +pub const ML_LOCKED_POS = @as(c_int, 0x08); +pub const ML_ALLOCATED = @as(c_int, 0x10); +pub const NVIM_OS_FS_DEFS_H = ""; +pub const UV_H = ""; +pub const UV_ERRNO_H_ = ""; +pub inline fn UV__ERR(x: anytype) @TypeOf(-x) { + return -x; +} +pub const UV__EOF = -@as(c_int, 4095); +pub const UV__UNKNOWN = -@as(c_int, 4094); +pub const UV__EAI_ADDRFAMILY = -@as(c_int, 3000); +pub const UV__EAI_AGAIN = -@as(c_int, 3001); +pub const UV__EAI_BADFLAGS = -@as(c_int, 3002); +pub const UV__EAI_CANCELED = -@as(c_int, 3003); +pub const UV__EAI_FAIL = -@as(c_int, 3004); +pub const UV__EAI_FAMILY = -@as(c_int, 3005); +pub const UV__EAI_MEMORY = -@as(c_int, 3006); +pub const UV__EAI_NODATA = -@as(c_int, 3007); +pub const UV__EAI_NONAME = -@as(c_int, 3008); +pub const UV__EAI_OVERFLOW = -@as(c_int, 3009); +pub const UV__EAI_SERVICE = -@as(c_int, 3010); +pub const UV__EAI_SOCKTYPE = -@as(c_int, 3011); +pub const UV__EAI_BADHINTS = -@as(c_int, 3013); +pub const UV__EAI_PROTOCOL = -@as(c_int, 3014); +pub const UV__E2BIG = UV__ERR(E2BIG); +pub const UV__EACCES = UV__ERR(EACCES); +pub const UV__EADDRINUSE = UV__ERR(EADDRINUSE); +pub const UV__EADDRNOTAVAIL = UV__ERR(EADDRNOTAVAIL); +pub const UV__EAFNOSUPPORT = UV__ERR(EAFNOSUPPORT); +pub const UV__EAGAIN = UV__ERR(EAGAIN); +pub const UV__EALREADY = UV__ERR(EALREADY); +pub const UV__EBADF = UV__ERR(EBADF); +pub const UV__EBUSY = UV__ERR(EBUSY); +pub const UV__ECANCELED = UV__ERR(ECANCELED); +pub const UV__ECHARSET = -@as(c_int, 4080); +pub const UV__ECONNABORTED = UV__ERR(ECONNABORTED); +pub const UV__ECONNREFUSED = UV__ERR(ECONNREFUSED); +pub const UV__ECONNRESET = UV__ERR(ECONNRESET); +pub const UV__EDESTADDRREQ = UV__ERR(EDESTADDRREQ); +pub const UV__EEXIST = UV__ERR(EEXIST); +pub const UV__EFAULT = UV__ERR(EFAULT); +pub const UV__EHOSTUNREACH = UV__ERR(EHOSTUNREACH); +pub const UV__EINTR = UV__ERR(EINTR); +pub const UV__EINVAL = UV__ERR(EINVAL); +pub const UV__EIO = UV__ERR(EIO); +pub const UV__EISCONN = UV__ERR(EISCONN); +pub const UV__EISDIR = UV__ERR(EISDIR); +pub const UV__ELOOP = UV__ERR(ELOOP); +pub const UV__EMFILE = UV__ERR(EMFILE); +pub const UV__EMSGSIZE = UV__ERR(EMSGSIZE); +pub const UV__ENAMETOOLONG = UV__ERR(ENAMETOOLONG); +pub const UV__ENETDOWN = UV__ERR(ENETDOWN); +pub const UV__ENETUNREACH = UV__ERR(ENETUNREACH); +pub const UV__ENFILE = UV__ERR(ENFILE); +pub const UV__ENOBUFS = UV__ERR(ENOBUFS); +pub const UV__ENODEV = UV__ERR(ENODEV); +pub const UV__ENOENT = UV__ERR(ENOENT); +pub const UV__ENOMEM = UV__ERR(ENOMEM); +pub const UV__ENONET = UV__ERR(ENONET); +pub const UV__ENOSPC = UV__ERR(ENOSPC); +pub const UV__ENOSYS = UV__ERR(ENOSYS); +pub const UV__ENOTCONN = UV__ERR(ENOTCONN); +pub const UV__ENOTDIR = UV__ERR(ENOTDIR); +pub const UV__ENOTEMPTY = UV__ERR(ENOTEMPTY); +pub const UV__ENOTSOCK = UV__ERR(ENOTSOCK); +pub const UV__ENOTSUP = UV__ERR(ENOTSUP); +pub const UV__EPERM = UV__ERR(EPERM); +pub const UV__EPIPE = UV__ERR(EPIPE); +pub const UV__EPROTO = UV__ERR(EPROTO); +pub const UV__EPROTONOSUPPORT = UV__ERR(EPROTONOSUPPORT); +pub const UV__EPROTOTYPE = UV__ERR(EPROTOTYPE); +pub const UV__EROFS = UV__ERR(EROFS); +pub const UV__ESHUTDOWN = UV__ERR(ESHUTDOWN); +pub const UV__ESPIPE = UV__ERR(ESPIPE); +pub const UV__ESRCH = UV__ERR(ESRCH); +pub const UV__ETIMEDOUT = UV__ERR(ETIMEDOUT); +pub const UV__ETXTBSY = UV__ERR(ETXTBSY); +pub const UV__EXDEV = UV__ERR(EXDEV); +pub const UV__EFBIG = UV__ERR(EFBIG); +pub const UV__ENOPROTOOPT = UV__ERR(ENOPROTOOPT); +pub const UV__ERANGE = UV__ERR(ERANGE); +pub const UV__ENXIO = UV__ERR(ENXIO); +pub const UV__EMLINK = UV__ERR(EMLINK); +pub const UV__EHOSTDOWN = UV__ERR(EHOSTDOWN); +pub const UV__EREMOTEIO = UV__ERR(EREMOTEIO); +pub const UV__ENOTTY = UV__ERR(ENOTTY); +pub const UV__EFTYPE = -@as(c_int, 4028); +pub const UV__EILSEQ = UV__ERR(EILSEQ); +pub const UV__EOVERFLOW = UV__ERR(EOVERFLOW); +pub const UV__ESOCKTNOSUPPORT = UV__ERR(ESOCKTNOSUPPORT); +pub const UV_VERSION_H = ""; +pub const UV_VERSION_MAJOR = @as(c_int, 1); +pub const UV_VERSION_MINOR = @as(c_int, 44); +pub const UV_VERSION_PATCH = @as(c_int, 2); +pub const UV_VERSION_IS_RELEASE = @as(c_int, 1); +pub const UV_VERSION_SUFFIX = ""; +pub const UV_VERSION_HEX = ((UV_VERSION_MAJOR << @as(c_int, 16)) | (UV_VERSION_MINOR << @as(c_int, 8))) | UV_VERSION_PATCH; +pub const UV_UNIX_H = ""; +pub const _FCNTL_H = @as(c_int, 1); +pub const __O_LARGEFILE = @as(c_int, 0); +pub const F_GETLK64 = @as(c_int, 5); +pub const F_SETLK64 = @as(c_int, 6); +pub const F_SETLKW64 = @as(c_int, 7); +pub const O_ACCMODE = @as(c_int, 0o003); +pub const O_RDONLY = @as(c_int, 0o0); +pub const O_WRONLY = @as(c_int, 0o1); +pub const O_RDWR = @as(c_int, 0o2); +pub const O_CREAT = @as(c_int, 0o100); +pub const O_EXCL = @as(c_int, 0o200); +pub const O_NOCTTY = @as(c_int, 0o400); +pub const O_TRUNC = @as(c_int, 0o1000); +pub const O_APPEND = @as(c_int, 0o2000); +pub const O_NONBLOCK = @as(c_int, 0o4000); +pub const O_NDELAY = O_NONBLOCK; +pub const O_SYNC = @import("std").zig.c_translation.promoteIntLiteral(c_int, 0o4010000, .octal); +pub const O_FSYNC = O_SYNC; +pub const O_ASYNC = @as(c_int, 0o20000); +pub const __O_DIRECTORY = @import("std").zig.c_translation.promoteIntLiteral(c_int, 0o200000, .octal); +pub const __O_NOFOLLOW = @import("std").zig.c_translation.promoteIntLiteral(c_int, 0o400000, .octal); +pub const __O_CLOEXEC = @import("std").zig.c_translation.promoteIntLiteral(c_int, 0o2000000, .octal); +pub const __O_DIRECT = @as(c_int, 0o40000); +pub const __O_NOATIME = @import("std").zig.c_translation.promoteIntLiteral(c_int, 0o1000000, .octal); +pub const __O_PATH = @import("std").zig.c_translation.promoteIntLiteral(c_int, 0o10000000, .octal); +pub const __O_DSYNC = @as(c_int, 0o10000); +pub const __O_TMPFILE = @import("std").zig.c_translation.promoteIntLiteral(c_int, 0o20000000, .octal) | __O_DIRECTORY; +pub const F_GETLK = @as(c_int, 5); +pub const F_SETLK = @as(c_int, 6); +pub const F_SETLKW = @as(c_int, 7); +pub const O_DIRECTORY = __O_DIRECTORY; +pub const O_NOFOLLOW = __O_NOFOLLOW; +pub const O_CLOEXEC = __O_CLOEXEC; +pub const O_DSYNC = __O_DSYNC; +pub const O_RSYNC = O_SYNC; +pub const F_DUPFD = @as(c_int, 0); +pub const F_GETFD = @as(c_int, 1); +pub const F_SETFD = @as(c_int, 2); +pub const F_GETFL = @as(c_int, 3); +pub const F_SETFL = @as(c_int, 4); +pub const __F_SETOWN = @as(c_int, 8); +pub const __F_GETOWN = @as(c_int, 9); +pub const F_SETOWN = __F_SETOWN; +pub const F_GETOWN = __F_GETOWN; +pub const __F_SETSIG = @as(c_int, 10); +pub const __F_GETSIG = @as(c_int, 11); +pub const __F_SETOWN_EX = @as(c_int, 15); +pub const __F_GETOWN_EX = @as(c_int, 16); +pub const F_DUPFD_CLOEXEC = @as(c_int, 1030); +pub const FD_CLOEXEC = @as(c_int, 1); +pub const F_RDLCK = @as(c_int, 0); +pub const F_WRLCK = @as(c_int, 1); +pub const F_UNLCK = @as(c_int, 2); +pub const F_EXLCK = @as(c_int, 4); +pub const F_SHLCK = @as(c_int, 8); +pub const LOCK_SH = @as(c_int, 1); +pub const LOCK_EX = @as(c_int, 2); +pub const LOCK_NB = @as(c_int, 4); +pub const LOCK_UN = @as(c_int, 8); +pub const FAPPEND = O_APPEND; +pub const FFSYNC = O_FSYNC; +pub const FASYNC = O_ASYNC; +pub const FNONBLOCK = O_NONBLOCK; +pub const FNDELAY = O_NDELAY; +pub const __POSIX_FADV_DONTNEED = @as(c_int, 4); +pub const __POSIX_FADV_NOREUSE = @as(c_int, 5); +pub const POSIX_FADV_NORMAL = @as(c_int, 0); +pub const POSIX_FADV_RANDOM = @as(c_int, 1); +pub const POSIX_FADV_SEQUENTIAL = @as(c_int, 2); +pub const POSIX_FADV_WILLNEED = @as(c_int, 3); +pub const POSIX_FADV_DONTNEED = __POSIX_FADV_DONTNEED; +pub const POSIX_FADV_NOREUSE = __POSIX_FADV_NOREUSE; +pub inline fn __OPEN_NEEDS_MODE(oflag: anytype) @TypeOf(((oflag & O_CREAT) != @as(c_int, 0)) or ((oflag & __O_TMPFILE) == __O_TMPFILE)) { + return ((oflag & O_CREAT) != @as(c_int, 0)) or ((oflag & __O_TMPFILE) == __O_TMPFILE); +} +pub const AT_FDCWD = -@as(c_int, 100); +pub const AT_SYMLINK_NOFOLLOW = @as(c_int, 0x100); +pub const AT_REMOVEDIR = @as(c_int, 0x200); +pub const AT_SYMLINK_FOLLOW = @as(c_int, 0x400); +pub const AT_EACCESS = @as(c_int, 0x200); +pub const _DIRENT_H = @as(c_int, 1); +pub const _DIRENT_HAVE_D_RECLEN = ""; +pub const _DIRENT_HAVE_D_OFF = ""; +pub const _DIRENT_HAVE_D_TYPE = ""; +pub const _DIRENT_MATCHES_DIRENT64 = @as(c_int, 1); +pub inline fn _D_EXACT_NAMLEN(d: anytype) @TypeOf(strlen(d.*.d_name)) { + return strlen(d.*.d_name); +} +pub inline fn _D_ALLOC_NAMLEN(d: anytype) @TypeOf((@import("std").zig.c_translation.cast([*c]u8, d) + d.*.d_reclen) - (&d.*.d_name[@intCast(usize, @as(c_int, 0))])) { + return (@import("std").zig.c_translation.cast([*c]u8, d) + d.*.d_reclen) - (&d.*.d_name[@intCast(usize, @as(c_int, 0))]); +} +pub inline fn IFTODT(mode: anytype) @TypeOf((mode & @import("std").zig.c_translation.promoteIntLiteral(c_int, 0o170000, .octal)) >> @as(c_int, 12)) { + return (mode & @import("std").zig.c_translation.promoteIntLiteral(c_int, 0o170000, .octal)) >> @as(c_int, 12); +} +pub inline fn DTTOIF(dirtype: anytype) @TypeOf(dirtype << @as(c_int, 12)) { + return dirtype << @as(c_int, 12); +} +pub const MAXNAMLEN = NAME_MAX; +pub const _SYS_SOCKET_H = @as(c_int, 1); +pub const __iovec_defined = @as(c_int, 1); +pub const __BITS_SOCKET_H = ""; +pub const PF_UNSPEC = @as(c_int, 0); +pub const PF_LOCAL = @as(c_int, 1); +pub const PF_UNIX = PF_LOCAL; +pub const PF_FILE = PF_LOCAL; +pub const PF_INET = @as(c_int, 2); +pub const PF_AX25 = @as(c_int, 3); +pub const PF_IPX = @as(c_int, 4); +pub const PF_APPLETALK = @as(c_int, 5); +pub const PF_NETROM = @as(c_int, 6); +pub const PF_BRIDGE = @as(c_int, 7); +pub const PF_ATMPVC = @as(c_int, 8); +pub const PF_X25 = @as(c_int, 9); +pub const PF_INET6 = @as(c_int, 10); +pub const PF_ROSE = @as(c_int, 11); +pub const PF_DECnet = @as(c_int, 12); +pub const PF_NETBEUI = @as(c_int, 13); +pub const PF_SECURITY = @as(c_int, 14); +pub const PF_KEY = @as(c_int, 15); +pub const PF_NETLINK = @as(c_int, 16); +pub const PF_ROUTE = PF_NETLINK; +pub const PF_PACKET = @as(c_int, 17); +pub const PF_ASH = @as(c_int, 18); +pub const PF_ECONET = @as(c_int, 19); +pub const PF_ATMSVC = @as(c_int, 20); +pub const PF_RDS = @as(c_int, 21); +pub const PF_SNA = @as(c_int, 22); +pub const PF_IRDA = @as(c_int, 23); +pub const PF_PPPOX = @as(c_int, 24); +pub const PF_WANPIPE = @as(c_int, 25); +pub const PF_LLC = @as(c_int, 26); +pub const PF_IB = @as(c_int, 27); +pub const PF_MPLS = @as(c_int, 28); +pub const PF_CAN = @as(c_int, 29); +pub const PF_TIPC = @as(c_int, 30); +pub const PF_BLUETOOTH = @as(c_int, 31); +pub const PF_IUCV = @as(c_int, 32); +pub const PF_RXRPC = @as(c_int, 33); +pub const PF_ISDN = @as(c_int, 34); +pub const PF_PHONET = @as(c_int, 35); +pub const PF_IEEE802154 = @as(c_int, 36); +pub const PF_CAIF = @as(c_int, 37); +pub const PF_ALG = @as(c_int, 38); +pub const PF_NFC = @as(c_int, 39); +pub const PF_VSOCK = @as(c_int, 40); +pub const PF_KCM = @as(c_int, 41); +pub const PF_QIPCRTR = @as(c_int, 42); +pub const PF_SMC = @as(c_int, 43); +pub const PF_XDP = @as(c_int, 44); +pub const PF_MCTP = @as(c_int, 45); +pub const PF_MAX = @as(c_int, 46); +pub const AF_UNSPEC = PF_UNSPEC; +pub const AF_LOCAL = PF_LOCAL; +pub const AF_UNIX = PF_UNIX; +pub const AF_FILE = PF_FILE; +pub const AF_INET = PF_INET; +pub const AF_AX25 = PF_AX25; +pub const AF_IPX = PF_IPX; +pub const AF_APPLETALK = PF_APPLETALK; +pub const AF_NETROM = PF_NETROM; +pub const AF_BRIDGE = PF_BRIDGE; +pub const AF_ATMPVC = PF_ATMPVC; +pub const AF_X25 = PF_X25; +pub const AF_INET6 = PF_INET6; +pub const AF_ROSE = PF_ROSE; +pub const AF_DECnet = PF_DECnet; +pub const AF_NETBEUI = PF_NETBEUI; +pub const AF_SECURITY = PF_SECURITY; +pub const AF_KEY = PF_KEY; +pub const AF_NETLINK = PF_NETLINK; +pub const AF_ROUTE = PF_ROUTE; +pub const AF_PACKET = PF_PACKET; +pub const AF_ASH = PF_ASH; +pub const AF_ECONET = PF_ECONET; +pub const AF_ATMSVC = PF_ATMSVC; +pub const AF_RDS = PF_RDS; +pub const AF_SNA = PF_SNA; +pub const AF_IRDA = PF_IRDA; +pub const AF_PPPOX = PF_PPPOX; +pub const AF_WANPIPE = PF_WANPIPE; +pub const AF_LLC = PF_LLC; +pub const AF_IB = PF_IB; +pub const AF_MPLS = PF_MPLS; +pub const AF_CAN = PF_CAN; +pub const AF_TIPC = PF_TIPC; +pub const AF_BLUETOOTH = PF_BLUETOOTH; +pub const AF_IUCV = PF_IUCV; +pub const AF_RXRPC = PF_RXRPC; +pub const AF_ISDN = PF_ISDN; +pub const AF_PHONET = PF_PHONET; +pub const AF_IEEE802154 = PF_IEEE802154; +pub const AF_CAIF = PF_CAIF; +pub const AF_ALG = PF_ALG; +pub const AF_NFC = PF_NFC; +pub const AF_VSOCK = PF_VSOCK; +pub const AF_KCM = PF_KCM; +pub const AF_QIPCRTR = PF_QIPCRTR; +pub const AF_SMC = PF_SMC; +pub const AF_XDP = PF_XDP; +pub const AF_MCTP = PF_MCTP; +pub const AF_MAX = PF_MAX; +pub const SOL_RAW = @as(c_int, 255); +pub const SOL_DECNET = @as(c_int, 261); +pub const SOL_X25 = @as(c_int, 262); +pub const SOL_PACKET = @as(c_int, 263); +pub const SOL_ATM = @as(c_int, 264); +pub const SOL_AAL = @as(c_int, 265); +pub const SOL_IRDA = @as(c_int, 266); +pub const SOL_NETBEUI = @as(c_int, 267); +pub const SOL_LLC = @as(c_int, 268); +pub const SOL_DCCP = @as(c_int, 269); +pub const SOL_NETLINK = @as(c_int, 270); +pub const SOL_TIPC = @as(c_int, 271); +pub const SOL_RXRPC = @as(c_int, 272); +pub const SOL_PPPOL2TP = @as(c_int, 273); +pub const SOL_BLUETOOTH = @as(c_int, 274); +pub const SOL_PNPIPE = @as(c_int, 275); +pub const SOL_RDS = @as(c_int, 276); +pub const SOL_IUCV = @as(c_int, 277); +pub const SOL_CAIF = @as(c_int, 278); +pub const SOL_ALG = @as(c_int, 279); +pub const SOL_NFC = @as(c_int, 280); +pub const SOL_KCM = @as(c_int, 281); +pub const SOL_TLS = @as(c_int, 282); +pub const SOL_XDP = @as(c_int, 283); +pub const SOL_MPTCP = @as(c_int, 284); +pub const SOL_MCTP = @as(c_int, 285); +pub const SOL_SMC = @as(c_int, 286); +pub const SOMAXCONN = @as(c_int, 4096); +pub const _BITS_SOCKADDR_H = @as(c_int, 1); +pub const __SOCKADDR_COMMON_SIZE = @import("std").zig.c_translation.sizeof(c_ushort); +pub const _SS_SIZE = @as(c_int, 128); +pub const __ss_aligntype = c_ulong; +pub const _SS_PADSIZE = (_SS_SIZE - __SOCKADDR_COMMON_SIZE) - @import("std").zig.c_translation.sizeof(__ss_aligntype); +pub inline fn CMSG_DATA(cmsg: anytype) @TypeOf(cmsg.*.__cmsg_data) { + return cmsg.*.__cmsg_data; +} +pub inline fn CMSG_NXTHDR(mhdr: anytype, cmsg: anytype) @TypeOf(__cmsg_nxthdr(mhdr, cmsg)) { + return __cmsg_nxthdr(mhdr, cmsg); +} +pub inline fn CMSG_FIRSTHDR(mhdr: anytype) @TypeOf(if (@import("std").zig.c_translation.cast(usize, mhdr.*.msg_controllen) >= @import("std").zig.c_translation.sizeof(struct_cmsghdr)) @import("std").zig.c_translation.cast([*c]struct_cmsghdr, mhdr.*.msg_control) else @import("std").zig.c_translation.cast([*c]struct_cmsghdr, @as(c_int, 0))) { + return if (@import("std").zig.c_translation.cast(usize, mhdr.*.msg_controllen) >= @import("std").zig.c_translation.sizeof(struct_cmsghdr)) @import("std").zig.c_translation.cast([*c]struct_cmsghdr, mhdr.*.msg_control) else @import("std").zig.c_translation.cast([*c]struct_cmsghdr, @as(c_int, 0)); +} +pub inline fn CMSG_ALIGN(len: anytype) @TypeOf(((len + @import("std").zig.c_translation.sizeof(usize)) - @as(c_int, 1)) & @import("std").zig.c_translation.cast(usize, ~(@import("std").zig.c_translation.sizeof(usize) - @as(c_int, 1)))) { + return ((len + @import("std").zig.c_translation.sizeof(usize)) - @as(c_int, 1)) & @import("std").zig.c_translation.cast(usize, ~(@import("std").zig.c_translation.sizeof(usize) - @as(c_int, 1))); +} +pub inline fn CMSG_SPACE(len: anytype) @TypeOf(CMSG_ALIGN(len) + CMSG_ALIGN(@import("std").zig.c_translation.sizeof(struct_cmsghdr))) { + return CMSG_ALIGN(len) + CMSG_ALIGN(@import("std").zig.c_translation.sizeof(struct_cmsghdr)); +} +pub inline fn CMSG_LEN(len: anytype) @TypeOf(CMSG_ALIGN(@import("std").zig.c_translation.sizeof(struct_cmsghdr)) + len) { + return CMSG_ALIGN(@import("std").zig.c_translation.sizeof(struct_cmsghdr)) + len; +} +pub inline fn __CMSG_PADDING(len: anytype) @TypeOf((@import("std").zig.c_translation.sizeof(usize) - (len & (@import("std").zig.c_translation.sizeof(usize) - @as(c_int, 1)))) & (@import("std").zig.c_translation.sizeof(usize) - @as(c_int, 1))) { + return (@import("std").zig.c_translation.sizeof(usize) - (len & (@import("std").zig.c_translation.sizeof(usize) - @as(c_int, 1)))) & (@import("std").zig.c_translation.sizeof(usize) - @as(c_int, 1)); +} +pub const __ASM_GENERIC_SOCKET_H = ""; +pub const _LINUX_POSIX_TYPES_H = ""; +pub const _LINUX_STDDEF_H = ""; +pub const _ASM_X86_POSIX_TYPES_64_H = ""; +pub const __ASM_GENERIC_POSIX_TYPES_H = ""; +pub const __ASM_X86_BITSPERLONG_H = ""; +pub const __BITS_PER_LONG = @as(c_int, 64); +pub const __ASM_GENERIC_BITS_PER_LONG = ""; +pub const __ASM_GENERIC_SOCKIOS_H = ""; +pub const FIOSETOWN = @import("std").zig.c_translation.promoteIntLiteral(c_int, 0x8901, .hexadecimal); +pub const SIOCSPGRP = @import("std").zig.c_translation.promoteIntLiteral(c_int, 0x8902, .hexadecimal); +pub const FIOGETOWN = @import("std").zig.c_translation.promoteIntLiteral(c_int, 0x8903, .hexadecimal); +pub const SIOCGPGRP = @import("std").zig.c_translation.promoteIntLiteral(c_int, 0x8904, .hexadecimal); +pub const SIOCATMARK = @import("std").zig.c_translation.promoteIntLiteral(c_int, 0x8905, .hexadecimal); +pub const SIOCGSTAMP_OLD = @import("std").zig.c_translation.promoteIntLiteral(c_int, 0x8906, .hexadecimal); +pub const SIOCGSTAMPNS_OLD = @import("std").zig.c_translation.promoteIntLiteral(c_int, 0x8907, .hexadecimal); +pub const SOL_SOCKET = @as(c_int, 1); +pub const SO_DEBUG = @as(c_int, 1); +pub const SO_REUSEADDR = @as(c_int, 2); +pub const SO_TYPE = @as(c_int, 3); +pub const SO_ERROR = @as(c_int, 4); +pub const SO_DONTROUTE = @as(c_int, 5); +pub const SO_BROADCAST = @as(c_int, 6); +pub const SO_SNDBUF = @as(c_int, 7); +pub const SO_RCVBUF = @as(c_int, 8); +pub const SO_SNDBUFFORCE = @as(c_int, 32); +pub const SO_RCVBUFFORCE = @as(c_int, 33); +pub const SO_KEEPALIVE = @as(c_int, 9); +pub const SO_OOBINLINE = @as(c_int, 10); +pub const SO_NO_CHECK = @as(c_int, 11); +pub const SO_PRIORITY = @as(c_int, 12); +pub const SO_LINGER = @as(c_int, 13); +pub const SO_BSDCOMPAT = @as(c_int, 14); +pub const SO_REUSEPORT = @as(c_int, 15); +pub const SO_PASSCRED = @as(c_int, 16); +pub const SO_PEERCRED = @as(c_int, 17); +pub const SO_RCVLOWAT = @as(c_int, 18); +pub const SO_SNDLOWAT = @as(c_int, 19); +pub const SO_RCVTIMEO_OLD = @as(c_int, 20); +pub const SO_SNDTIMEO_OLD = @as(c_int, 21); +pub const SO_SECURITY_AUTHENTICATION = @as(c_int, 22); +pub const SO_SECURITY_ENCRYPTION_TRANSPORT = @as(c_int, 23); +pub const SO_SECURITY_ENCRYPTION_NETWORK = @as(c_int, 24); +pub const SO_BINDTODEVICE = @as(c_int, 25); +pub const SO_ATTACH_FILTER = @as(c_int, 26); +pub const SO_DETACH_FILTER = @as(c_int, 27); +pub const SO_GET_FILTER = SO_ATTACH_FILTER; +pub const SO_PEERNAME = @as(c_int, 28); +pub const SO_ACCEPTCONN = @as(c_int, 30); +pub const SO_PEERSEC = @as(c_int, 31); +pub const SO_PASSSEC = @as(c_int, 34); +pub const SO_MARK = @as(c_int, 36); +pub const SO_PROTOCOL = @as(c_int, 38); +pub const SO_DOMAIN = @as(c_int, 39); +pub const SO_RXQ_OVFL = @as(c_int, 40); +pub const SO_WIFI_STATUS = @as(c_int, 41); +pub const SCM_WIFI_STATUS = SO_WIFI_STATUS; +pub const SO_PEEK_OFF = @as(c_int, 42); +pub const SO_NOFCS = @as(c_int, 43); +pub const SO_LOCK_FILTER = @as(c_int, 44); +pub const SO_SELECT_ERR_QUEUE = @as(c_int, 45); +pub const SO_BUSY_POLL = @as(c_int, 46); +pub const SO_MAX_PACING_RATE = @as(c_int, 47); +pub const SO_BPF_EXTENSIONS = @as(c_int, 48); +pub const SO_INCOMING_CPU = @as(c_int, 49); +pub const SO_ATTACH_BPF = @as(c_int, 50); +pub const SO_DETACH_BPF = SO_DETACH_FILTER; +pub const SO_ATTACH_REUSEPORT_CBPF = @as(c_int, 51); +pub const SO_ATTACH_REUSEPORT_EBPF = @as(c_int, 52); +pub const SO_CNX_ADVICE = @as(c_int, 53); +pub const SCM_TIMESTAMPING_OPT_STATS = @as(c_int, 54); +pub const SO_MEMINFO = @as(c_int, 55); +pub const SO_INCOMING_NAPI_ID = @as(c_int, 56); +pub const SO_COOKIE = @as(c_int, 57); +pub const SCM_TIMESTAMPING_PKTINFO = @as(c_int, 58); +pub const SO_PEERGROUPS = @as(c_int, 59); +pub const SO_ZEROCOPY = @as(c_int, 60); +pub const SO_TXTIME = @as(c_int, 61); +pub const SCM_TXTIME = SO_TXTIME; +pub const SO_BINDTOIFINDEX = @as(c_int, 62); +pub const SO_TIMESTAMP_OLD = @as(c_int, 29); +pub const SO_TIMESTAMPNS_OLD = @as(c_int, 35); +pub const SO_TIMESTAMPING_OLD = @as(c_int, 37); +pub const SO_TIMESTAMP_NEW = @as(c_int, 63); +pub const SO_TIMESTAMPNS_NEW = @as(c_int, 64); +pub const SO_TIMESTAMPING_NEW = @as(c_int, 65); +pub const SO_RCVTIMEO_NEW = @as(c_int, 66); +pub const SO_SNDTIMEO_NEW = @as(c_int, 67); +pub const SO_DETACH_REUSEPORT_BPF = @as(c_int, 68); +pub const SO_PREFER_BUSY_POLL = @as(c_int, 69); +pub const SO_BUSY_POLL_BUDGET = @as(c_int, 70); +pub const SO_NETNS_COOKIE = @as(c_int, 71); +pub const SO_BUF_LOCK = @as(c_int, 72); +pub const SO_RESERVE_MEM = @as(c_int, 73); +pub const SO_TXREHASH = @as(c_int, 74); +pub const SO_RCVMARK = @as(c_int, 75); +pub const SO_TIMESTAMP = SO_TIMESTAMP_OLD; +pub const SO_TIMESTAMPNS = SO_TIMESTAMPNS_OLD; +pub const SO_TIMESTAMPING = SO_TIMESTAMPING_OLD; +pub const SO_RCVTIMEO = SO_RCVTIMEO_OLD; +pub const SO_SNDTIMEO = SO_SNDTIMEO_OLD; +pub const SCM_TIMESTAMP = SO_TIMESTAMP; +pub const SCM_TIMESTAMPNS = SO_TIMESTAMPNS; +pub const SCM_TIMESTAMPING = SO_TIMESTAMPING; +pub const __osockaddr_defined = @as(c_int, 1); +pub const _NETINET_IN_H = @as(c_int, 1); +pub const __USE_KERNEL_IPV6_DEFS = @as(c_int, 0); +pub const IP_OPTIONS = @as(c_int, 4); +pub const IP_HDRINCL = @as(c_int, 3); +pub const IP_TOS = @as(c_int, 1); +pub const IP_TTL = @as(c_int, 2); +pub const IP_RECVOPTS = @as(c_int, 6); +pub const IP_RECVRETOPTS = IP_RETOPTS; +pub const IP_RETOPTS = @as(c_int, 7); +pub const IP_MULTICAST_IF = @as(c_int, 32); +pub const IP_MULTICAST_TTL = @as(c_int, 33); +pub const IP_MULTICAST_LOOP = @as(c_int, 34); +pub const IP_ADD_MEMBERSHIP = @as(c_int, 35); +pub const IP_DROP_MEMBERSHIP = @as(c_int, 36); +pub const IP_UNBLOCK_SOURCE = @as(c_int, 37); +pub const IP_BLOCK_SOURCE = @as(c_int, 38); +pub const IP_ADD_SOURCE_MEMBERSHIP = @as(c_int, 39); +pub const IP_DROP_SOURCE_MEMBERSHIP = @as(c_int, 40); +pub const IP_MSFILTER = @as(c_int, 41); +pub const MCAST_JOIN_GROUP = @as(c_int, 42); +pub const MCAST_BLOCK_SOURCE = @as(c_int, 43); +pub const MCAST_UNBLOCK_SOURCE = @as(c_int, 44); +pub const MCAST_LEAVE_GROUP = @as(c_int, 45); +pub const MCAST_JOIN_SOURCE_GROUP = @as(c_int, 46); +pub const MCAST_LEAVE_SOURCE_GROUP = @as(c_int, 47); +pub const MCAST_MSFILTER = @as(c_int, 48); +pub const IP_MULTICAST_ALL = @as(c_int, 49); +pub const IP_UNICAST_IF = @as(c_int, 50); +pub const MCAST_EXCLUDE = @as(c_int, 0); +pub const MCAST_INCLUDE = @as(c_int, 1); +pub const IP_ROUTER_ALERT = @as(c_int, 5); +pub const IP_PKTINFO = @as(c_int, 8); +pub const IP_PKTOPTIONS = @as(c_int, 9); +pub const IP_PMTUDISC = @as(c_int, 10); +pub const IP_MTU_DISCOVER = @as(c_int, 10); +pub const IP_RECVERR = @as(c_int, 11); +pub const IP_RECVTTL = @as(c_int, 12); +pub const IP_RECVTOS = @as(c_int, 13); +pub const IP_MTU = @as(c_int, 14); +pub const IP_FREEBIND = @as(c_int, 15); +pub const IP_IPSEC_POLICY = @as(c_int, 16); +pub const IP_XFRM_POLICY = @as(c_int, 17); +pub const IP_PASSSEC = @as(c_int, 18); +pub const IP_TRANSPARENT = @as(c_int, 19); +pub const IP_ORIGDSTADDR = @as(c_int, 20); +pub const IP_RECVORIGDSTADDR = IP_ORIGDSTADDR; +pub const IP_MINTTL = @as(c_int, 21); +pub const IP_NODEFRAG = @as(c_int, 22); +pub const IP_CHECKSUM = @as(c_int, 23); +pub const IP_BIND_ADDRESS_NO_PORT = @as(c_int, 24); +pub const IP_RECVFRAGSIZE = @as(c_int, 25); +pub const IP_RECVERR_RFC4884 = @as(c_int, 26); +pub const IP_PMTUDISC_DONT = @as(c_int, 0); +pub const IP_PMTUDISC_WANT = @as(c_int, 1); +pub const IP_PMTUDISC_DO = @as(c_int, 2); +pub const IP_PMTUDISC_PROBE = @as(c_int, 3); +pub const IP_PMTUDISC_INTERFACE = @as(c_int, 4); +pub const IP_PMTUDISC_OMIT = @as(c_int, 5); +pub const SOL_IP = @as(c_int, 0); +pub const IP_DEFAULT_MULTICAST_TTL = @as(c_int, 1); +pub const IP_DEFAULT_MULTICAST_LOOP = @as(c_int, 1); +pub const IP_MAX_MEMBERSHIPS = @as(c_int, 20); +pub const IPV6_ADDRFORM = @as(c_int, 1); +pub const IPV6_2292PKTINFO = @as(c_int, 2); +pub const IPV6_2292HOPOPTS = @as(c_int, 3); +pub const IPV6_2292DSTOPTS = @as(c_int, 4); +pub const IPV6_2292RTHDR = @as(c_int, 5); +pub const IPV6_2292PKTOPTIONS = @as(c_int, 6); +pub const IPV6_CHECKSUM = @as(c_int, 7); +pub const IPV6_2292HOPLIMIT = @as(c_int, 8); +pub const IPV6_NEXTHOP = @as(c_int, 9); +pub const IPV6_AUTHHDR = @as(c_int, 10); +pub const IPV6_UNICAST_HOPS = @as(c_int, 16); +pub const IPV6_MULTICAST_IF = @as(c_int, 17); +pub const IPV6_MULTICAST_HOPS = @as(c_int, 18); +pub const IPV6_MULTICAST_LOOP = @as(c_int, 19); +pub const IPV6_JOIN_GROUP = @as(c_int, 20); +pub const IPV6_LEAVE_GROUP = @as(c_int, 21); +pub const IPV6_ROUTER_ALERT = @as(c_int, 22); +pub const IPV6_MTU_DISCOVER = @as(c_int, 23); +pub const IPV6_MTU = @as(c_int, 24); +pub const IPV6_RECVERR = @as(c_int, 25); +pub const IPV6_V6ONLY = @as(c_int, 26); +pub const IPV6_JOIN_ANYCAST = @as(c_int, 27); +pub const IPV6_LEAVE_ANYCAST = @as(c_int, 28); +pub const IPV6_MULTICAST_ALL = @as(c_int, 29); +pub const IPV6_ROUTER_ALERT_ISOLATE = @as(c_int, 30); +pub const IPV6_RECVERR_RFC4884 = @as(c_int, 31); +pub const IPV6_IPSEC_POLICY = @as(c_int, 34); +pub const IPV6_XFRM_POLICY = @as(c_int, 35); +pub const IPV6_HDRINCL = @as(c_int, 36); +pub const IPV6_RECVPKTINFO = @as(c_int, 49); +pub const IPV6_PKTINFO = @as(c_int, 50); +pub const IPV6_RECVHOPLIMIT = @as(c_int, 51); +pub const IPV6_HOPLIMIT = @as(c_int, 52); +pub const IPV6_RECVHOPOPTS = @as(c_int, 53); +pub const IPV6_HOPOPTS = @as(c_int, 54); +pub const IPV6_RTHDRDSTOPTS = @as(c_int, 55); +pub const IPV6_RECVRTHDR = @as(c_int, 56); +pub const IPV6_RTHDR = @as(c_int, 57); +pub const IPV6_RECVDSTOPTS = @as(c_int, 58); +pub const IPV6_DSTOPTS = @as(c_int, 59); +pub const IPV6_RECVPATHMTU = @as(c_int, 60); +pub const IPV6_PATHMTU = @as(c_int, 61); +pub const IPV6_DONTFRAG = @as(c_int, 62); +pub const IPV6_RECVTCLASS = @as(c_int, 66); +pub const IPV6_TCLASS = @as(c_int, 67); +pub const IPV6_AUTOFLOWLABEL = @as(c_int, 70); +pub const IPV6_ADDR_PREFERENCES = @as(c_int, 72); +pub const IPV6_MINHOPCOUNT = @as(c_int, 73); +pub const IPV6_ORIGDSTADDR = @as(c_int, 74); +pub const IPV6_RECVORIGDSTADDR = IPV6_ORIGDSTADDR; +pub const IPV6_TRANSPARENT = @as(c_int, 75); +pub const IPV6_UNICAST_IF = @as(c_int, 76); +pub const IPV6_RECVFRAGSIZE = @as(c_int, 77); +pub const IPV6_FREEBIND = @as(c_int, 78); +pub const IPV6_ADD_MEMBERSHIP = IPV6_JOIN_GROUP; +pub const IPV6_DROP_MEMBERSHIP = IPV6_LEAVE_GROUP; +pub const IPV6_RXHOPOPTS = IPV6_HOPOPTS; +pub const IPV6_RXDSTOPTS = IPV6_DSTOPTS; +pub const IPV6_PMTUDISC_DONT = @as(c_int, 0); +pub const IPV6_PMTUDISC_WANT = @as(c_int, 1); +pub const IPV6_PMTUDISC_DO = @as(c_int, 2); +pub const IPV6_PMTUDISC_PROBE = @as(c_int, 3); +pub const IPV6_PMTUDISC_INTERFACE = @as(c_int, 4); +pub const IPV6_PMTUDISC_OMIT = @as(c_int, 5); +pub const SOL_IPV6 = @as(c_int, 41); +pub const SOL_ICMPV6 = @as(c_int, 58); +pub const IPV6_RTHDR_LOOSE = @as(c_int, 0); +pub const IPV6_RTHDR_STRICT = @as(c_int, 1); +pub const IPV6_RTHDR_TYPE_0 = @as(c_int, 0); +pub inline fn IN_CLASSA(a: anytype) @TypeOf((@import("std").zig.c_translation.cast(in_addr_t, a) & @import("std").zig.c_translation.promoteIntLiteral(c_int, 0x80000000, .hexadecimal)) == @as(c_int, 0)) { + return (@import("std").zig.c_translation.cast(in_addr_t, a) & @import("std").zig.c_translation.promoteIntLiteral(c_int, 0x80000000, .hexadecimal)) == @as(c_int, 0); +} +pub const IN_CLASSA_NET = @import("std").zig.c_translation.promoteIntLiteral(c_int, 0xff000000, .hexadecimal); +pub const IN_CLASSA_NSHIFT = @as(c_int, 24); +pub const IN_CLASSA_HOST = @import("std").zig.c_translation.promoteIntLiteral(c_int, 0xffffffff, .hexadecimal) & ~IN_CLASSA_NET; +pub const IN_CLASSA_MAX = @as(c_int, 128); +pub inline fn IN_CLASSB(a: anytype) @TypeOf((@import("std").zig.c_translation.cast(in_addr_t, a) & @import("std").zig.c_translation.promoteIntLiteral(c_int, 0xc0000000, .hexadecimal)) == @import("std").zig.c_translation.promoteIntLiteral(c_int, 0x80000000, .hexadecimal)) { + return (@import("std").zig.c_translation.cast(in_addr_t, a) & @import("std").zig.c_translation.promoteIntLiteral(c_int, 0xc0000000, .hexadecimal)) == @import("std").zig.c_translation.promoteIntLiteral(c_int, 0x80000000, .hexadecimal); +} +pub const IN_CLASSB_NET = @import("std").zig.c_translation.promoteIntLiteral(c_int, 0xffff0000, .hexadecimal); +pub const IN_CLASSB_NSHIFT = @as(c_int, 16); +pub const IN_CLASSB_HOST = @import("std").zig.c_translation.promoteIntLiteral(c_int, 0xffffffff, .hexadecimal) & ~IN_CLASSB_NET; +pub const IN_CLASSB_MAX = @import("std").zig.c_translation.promoteIntLiteral(c_int, 65536, .decimal); +pub inline fn IN_CLASSC(a: anytype) @TypeOf((@import("std").zig.c_translation.cast(in_addr_t, a) & @import("std").zig.c_translation.promoteIntLiteral(c_int, 0xe0000000, .hexadecimal)) == @import("std").zig.c_translation.promoteIntLiteral(c_int, 0xc0000000, .hexadecimal)) { + return (@import("std").zig.c_translation.cast(in_addr_t, a) & @import("std").zig.c_translation.promoteIntLiteral(c_int, 0xe0000000, .hexadecimal)) == @import("std").zig.c_translation.promoteIntLiteral(c_int, 0xc0000000, .hexadecimal); +} +pub const IN_CLASSC_NET = @import("std").zig.c_translation.promoteIntLiteral(c_int, 0xffffff00, .hexadecimal); +pub const IN_CLASSC_NSHIFT = @as(c_int, 8); +pub const IN_CLASSC_HOST = @import("std").zig.c_translation.promoteIntLiteral(c_int, 0xffffffff, .hexadecimal) & ~IN_CLASSC_NET; +pub inline fn IN_CLASSD(a: anytype) @TypeOf((@import("std").zig.c_translation.cast(in_addr_t, a) & @import("std").zig.c_translation.promoteIntLiteral(c_int, 0xf0000000, .hexadecimal)) == @import("std").zig.c_translation.promoteIntLiteral(c_int, 0xe0000000, .hexadecimal)) { + return (@import("std").zig.c_translation.cast(in_addr_t, a) & @import("std").zig.c_translation.promoteIntLiteral(c_int, 0xf0000000, .hexadecimal)) == @import("std").zig.c_translation.promoteIntLiteral(c_int, 0xe0000000, .hexadecimal); +} +pub inline fn IN_MULTICAST(a: anytype) @TypeOf(IN_CLASSD(a)) { + return IN_CLASSD(a); +} +pub inline fn IN_EXPERIMENTAL(a: anytype) @TypeOf((@import("std").zig.c_translation.cast(in_addr_t, a) & @import("std").zig.c_translation.promoteIntLiteral(c_int, 0xe0000000, .hexadecimal)) == @import("std").zig.c_translation.promoteIntLiteral(c_int, 0xe0000000, .hexadecimal)) { + return (@import("std").zig.c_translation.cast(in_addr_t, a) & @import("std").zig.c_translation.promoteIntLiteral(c_int, 0xe0000000, .hexadecimal)) == @import("std").zig.c_translation.promoteIntLiteral(c_int, 0xe0000000, .hexadecimal); +} +pub inline fn IN_BADCLASS(a: anytype) @TypeOf((@import("std").zig.c_translation.cast(in_addr_t, a) & @import("std").zig.c_translation.promoteIntLiteral(c_int, 0xf0000000, .hexadecimal)) == @import("std").zig.c_translation.promoteIntLiteral(c_int, 0xf0000000, .hexadecimal)) { + return (@import("std").zig.c_translation.cast(in_addr_t, a) & @import("std").zig.c_translation.promoteIntLiteral(c_int, 0xf0000000, .hexadecimal)) == @import("std").zig.c_translation.promoteIntLiteral(c_int, 0xf0000000, .hexadecimal); +} +pub const INADDR_ANY = @import("std").zig.c_translation.cast(in_addr_t, @as(c_int, 0x00000000)); +pub const INADDR_BROADCAST = @import("std").zig.c_translation.cast(in_addr_t, @import("std").zig.c_translation.promoteIntLiteral(c_int, 0xffffffff, .hexadecimal)); +pub const INADDR_NONE = @import("std").zig.c_translation.cast(in_addr_t, @import("std").zig.c_translation.promoteIntLiteral(c_int, 0xffffffff, .hexadecimal)); +pub const INADDR_DUMMY = @import("std").zig.c_translation.cast(in_addr_t, @import("std").zig.c_translation.promoteIntLiteral(c_int, 0xc0000008, .hexadecimal)); +pub const IN_LOOPBACKNET = @as(c_int, 127); +pub const INADDR_LOOPBACK = @import("std").zig.c_translation.cast(in_addr_t, @import("std").zig.c_translation.promoteIntLiteral(c_int, 0x7f000001, .hexadecimal)); +pub const INADDR_UNSPEC_GROUP = @import("std").zig.c_translation.cast(in_addr_t, @import("std").zig.c_translation.promoteIntLiteral(c_int, 0xe0000000, .hexadecimal)); +pub const INADDR_ALLHOSTS_GROUP = @import("std").zig.c_translation.cast(in_addr_t, @import("std").zig.c_translation.promoteIntLiteral(c_int, 0xe0000001, .hexadecimal)); +pub const INADDR_ALLRTRS_GROUP = @import("std").zig.c_translation.cast(in_addr_t, @import("std").zig.c_translation.promoteIntLiteral(c_int, 0xe0000002, .hexadecimal)); +pub const INADDR_ALLSNOOPERS_GROUP = @import("std").zig.c_translation.cast(in_addr_t, @import("std").zig.c_translation.promoteIntLiteral(c_int, 0xe000006a, .hexadecimal)); +pub const INADDR_MAX_LOCAL_GROUP = @import("std").zig.c_translation.cast(in_addr_t, @import("std").zig.c_translation.promoteIntLiteral(c_int, 0xe00000ff, .hexadecimal)); +pub const INET_ADDRSTRLEN = @as(c_int, 16); +pub const INET6_ADDRSTRLEN = @as(c_int, 46); +pub inline fn IP_MSFILTER_SIZE(numsrc: anytype) @TypeOf((@import("std").zig.c_translation.sizeof(struct_ip_msfilter) - @import("std").zig.c_translation.sizeof(struct_in_addr)) + (numsrc * @import("std").zig.c_translation.sizeof(struct_in_addr))) { + return (@import("std").zig.c_translation.sizeof(struct_ip_msfilter) - @import("std").zig.c_translation.sizeof(struct_in_addr)) + (numsrc * @import("std").zig.c_translation.sizeof(struct_in_addr)); +} +pub inline fn GROUP_FILTER_SIZE(numsrc: anytype) @TypeOf((@import("std").zig.c_translation.sizeof(struct_group_filter) - @import("std").zig.c_translation.sizeof(struct_sockaddr_storage)) + (numsrc * @import("std").zig.c_translation.sizeof(struct_sockaddr_storage))) { + return (@import("std").zig.c_translation.sizeof(struct_group_filter) - @import("std").zig.c_translation.sizeof(struct_sockaddr_storage)) + (numsrc * @import("std").zig.c_translation.sizeof(struct_sockaddr_storage)); +} +pub const _NETINET_TCP_H = @as(c_int, 1); +pub const TCP_NODELAY = @as(c_int, 1); +pub const TCP_MAXSEG = @as(c_int, 2); +pub const TCP_CORK = @as(c_int, 3); +pub const TCP_KEEPIDLE = @as(c_int, 4); +pub const TCP_KEEPINTVL = @as(c_int, 5); +pub const TCP_KEEPCNT = @as(c_int, 6); +pub const TCP_SYNCNT = @as(c_int, 7); +pub const TCP_LINGER2 = @as(c_int, 8); +pub const TCP_DEFER_ACCEPT = @as(c_int, 9); +pub const TCP_WINDOW_CLAMP = @as(c_int, 10); +pub const TCP_INFO = @as(c_int, 11); +pub const TCP_QUICKACK = @as(c_int, 12); +pub const TCP_CONGESTION = @as(c_int, 13); +pub const TCP_MD5SIG = @as(c_int, 14); +pub const TCP_COOKIE_TRANSACTIONS = @as(c_int, 15); +pub const TCP_THIN_LINEAR_TIMEOUTS = @as(c_int, 16); +pub const TCP_THIN_DUPACK = @as(c_int, 17); +pub const TCP_USER_TIMEOUT = @as(c_int, 18); +pub const TCP_REPAIR = @as(c_int, 19); +pub const TCP_REPAIR_QUEUE = @as(c_int, 20); +pub const TCP_QUEUE_SEQ = @as(c_int, 21); +pub const TCP_REPAIR_OPTIONS = @as(c_int, 22); +pub const TCP_FASTOPEN = @as(c_int, 23); +pub const TCP_TIMESTAMP = @as(c_int, 24); +pub const TCP_NOTSENT_LOWAT = @as(c_int, 25); +pub const TCP_CC_INFO = @as(c_int, 26); +pub const TCP_SAVE_SYN = @as(c_int, 27); +pub const TCP_SAVED_SYN = @as(c_int, 28); +pub const TCP_REPAIR_WINDOW = @as(c_int, 29); +pub const TCP_FASTOPEN_CONNECT = @as(c_int, 30); +pub const TCP_ULP = @as(c_int, 31); +pub const TCP_MD5SIG_EXT = @as(c_int, 32); +pub const TCP_FASTOPEN_KEY = @as(c_int, 33); +pub const TCP_FASTOPEN_NO_COOKIE = @as(c_int, 34); +pub const TCP_ZEROCOPY_RECEIVE = @as(c_int, 35); +pub const TCP_INQ = @as(c_int, 36); +pub const TCP_CM_INQ = TCP_INQ; +pub const TCP_TX_DELAY = @as(c_int, 37); +pub const TCP_REPAIR_ON = @as(c_int, 1); +pub const TCP_REPAIR_OFF = @as(c_int, 0); +pub const TCP_REPAIR_OFF_NO_WP = -@as(c_int, 1); +pub const TH_FIN = @as(c_int, 0x01); +pub const TH_SYN = @as(c_int, 0x02); +pub const TH_RST = @as(c_int, 0x04); +pub const TH_PUSH = @as(c_int, 0x08); +pub const TH_ACK = @as(c_int, 0x10); +pub const TH_URG = @as(c_int, 0x20); +pub const TCPOPT_EOL = @as(c_int, 0); +pub const TCPOPT_NOP = @as(c_int, 1); +pub const TCPOPT_MAXSEG = @as(c_int, 2); +pub const TCPOLEN_MAXSEG = @as(c_int, 4); +pub const TCPOPT_WINDOW = @as(c_int, 3); +pub const TCPOLEN_WINDOW = @as(c_int, 3); +pub const TCPOPT_SACK_PERMITTED = @as(c_int, 4); +pub const TCPOLEN_SACK_PERMITTED = @as(c_int, 2); +pub const TCPOPT_SACK = @as(c_int, 5); +pub const TCPOPT_TIMESTAMP = @as(c_int, 8); +pub const TCPOLEN_TIMESTAMP = @as(c_int, 10); +pub const TCPOLEN_TSTAMP_APPA = TCPOLEN_TIMESTAMP + @as(c_int, 2); +pub const TCPOPT_TSTAMP_HDR = (((TCPOPT_NOP << @as(c_int, 24)) | (TCPOPT_NOP << @as(c_int, 16))) | (TCPOPT_TIMESTAMP << @as(c_int, 8))) | TCPOLEN_TIMESTAMP; +pub const TCP_MSS = @as(c_int, 512); +pub const TCP_MAXWIN = @import("std").zig.c_translation.promoteIntLiteral(c_int, 65535, .decimal); +pub const TCP_MAX_WINSHIFT = @as(c_int, 14); +pub const SOL_TCP = @as(c_int, 6); +pub const TCPI_OPT_TIMESTAMPS = @as(c_int, 1); +pub const TCPI_OPT_SACK = @as(c_int, 2); +pub const TCPI_OPT_WSCALE = @as(c_int, 4); +pub const TCPI_OPT_ECN = @as(c_int, 8); +pub const TCPI_OPT_ECN_SEEN = @as(c_int, 16); +pub const TCPI_OPT_SYN_DATA = @as(c_int, 32); +pub const TCP_MD5SIG_MAXKEYLEN = @as(c_int, 80); +pub const TCP_MD5SIG_FLAG_PREFIX = @as(c_int, 1); +pub const TCP_COOKIE_MIN = @as(c_int, 8); +pub const TCP_COOKIE_MAX = @as(c_int, 16); +pub const TCP_COOKIE_PAIR_SIZE = @as(c_int, 2) * TCP_COOKIE_MAX; +pub const TCP_COOKIE_IN_ALWAYS = @as(c_int, 1) << @as(c_int, 0); +pub const TCP_COOKIE_OUT_NEVER = @as(c_int, 1) << @as(c_int, 1); +pub const TCP_S_DATA_IN = @as(c_int, 1) << @as(c_int, 2); +pub const TCP_S_DATA_OUT = @as(c_int, 1) << @as(c_int, 3); +pub const TCP_MSS_DEFAULT = @as(c_uint, 536); +pub const TCP_MSS_DESIRED = @as(c_uint, 1220); +pub const _ARPA_INET_H = @as(c_int, 1); +pub const _NETDB_H = @as(c_int, 1); +pub const _RPC_NETDB_H = @as(c_int, 1); +pub const _PATH_HEQUIV = "/etc/hosts.equiv"; +pub const _PATH_HOSTS = "/etc/hosts"; +pub const _PATH_NETWORKS = "/etc/networks"; +pub const _PATH_NSSWITCH_CONF = "/etc/nsswitch.conf"; +pub const _PATH_PROTOCOLS = "/etc/protocols"; +pub const _PATH_SERVICES = "/etc/services"; +pub const h_errno = __h_errno_location().*; +pub const HOST_NOT_FOUND = @as(c_int, 1); +pub const TRY_AGAIN = @as(c_int, 2); +pub const NO_RECOVERY = @as(c_int, 3); +pub const NO_DATA = @as(c_int, 4); +pub const NETDB_INTERNAL = -@as(c_int, 1); +pub const NETDB_SUCCESS = @as(c_int, 0); +pub const NO_ADDRESS = NO_DATA; +pub const AI_PASSIVE = @as(c_int, 0x0001); +pub const AI_CANONNAME = @as(c_int, 0x0002); +pub const AI_NUMERICHOST = @as(c_int, 0x0004); +pub const AI_V4MAPPED = @as(c_int, 0x0008); +pub const AI_ALL = @as(c_int, 0x0010); +pub const AI_ADDRCONFIG = @as(c_int, 0x0020); +pub const AI_NUMERICSERV = @as(c_int, 0x0400); +pub const EAI_BADFLAGS = -@as(c_int, 1); +pub const EAI_NONAME = -@as(c_int, 2); +pub const EAI_AGAIN = -@as(c_int, 3); +pub const EAI_FAIL = -@as(c_int, 4); +pub const EAI_FAMILY = -@as(c_int, 6); +pub const EAI_SOCKTYPE = -@as(c_int, 7); +pub const EAI_SERVICE = -@as(c_int, 8); +pub const EAI_MEMORY = -@as(c_int, 10); +pub const EAI_SYSTEM = -@as(c_int, 11); +pub const EAI_OVERFLOW = -@as(c_int, 12); +pub const NI_MAXHOST = @as(c_int, 1025); +pub const NI_MAXSERV = @as(c_int, 32); +pub const NI_NUMERICHOST = @as(c_int, 1); +pub const NI_NUMERICSERV = @as(c_int, 2); +pub const NI_NOFQDN = @as(c_int, 4); +pub const NI_NAMEREQD = @as(c_int, 8); +pub const NI_DGRAM = @as(c_int, 16); +pub const _PWD_H = @as(c_int, 1); +pub const NSS_BUFLEN_PASSWD = @as(c_int, 1024); +pub const _SEMAPHORE_H = @as(c_int, 1); +pub const __SIZEOF_SEM_T = @as(c_int, 32); +pub const SEM_FAILED = @import("std").zig.c_translation.cast([*c]sem_t, @as(c_int, 0)); +pub const _PTHREAD_H = @as(c_int, 1); +pub const _SCHED_H = @as(c_int, 1); +pub const _BITS_SCHED_H = @as(c_int, 1); +pub const SCHED_OTHER = @as(c_int, 0); +pub const SCHED_FIFO = @as(c_int, 1); +pub const SCHED_RR = @as(c_int, 2); +pub const _BITS_TYPES_STRUCT_SCHED_PARAM = @as(c_int, 1); +pub const _BITS_CPU_SET_H = @as(c_int, 1); +pub const __CPU_SETSIZE = @as(c_int, 1024); +pub const __NCPUBITS = @as(c_int, 8) * @import("std").zig.c_translation.sizeof(__cpu_mask); +pub inline fn __CPUELT(cpu: anytype) @TypeOf(@import("std").zig.c_translation.MacroArithmetic.div(cpu, __NCPUBITS)) { + return @import("std").zig.c_translation.MacroArithmetic.div(cpu, __NCPUBITS); +} +pub inline fn __CPUMASK(cpu: anytype) @TypeOf(@import("std").zig.c_translation.cast(__cpu_mask, @as(c_int, 1)) << @import("std").zig.c_translation.MacroArithmetic.rem(cpu, __NCPUBITS)) { + return @import("std").zig.c_translation.cast(__cpu_mask, @as(c_int, 1)) << @import("std").zig.c_translation.MacroArithmetic.rem(cpu, __NCPUBITS); +} +pub inline fn __CPU_COUNT_S(setsize: anytype, cpusetp: anytype) @TypeOf(__sched_cpucount(setsize, cpusetp)) { + return __sched_cpucount(setsize, cpusetp); +} +pub inline fn __CPU_ALLOC_SIZE(count: anytype) @TypeOf(@import("std").zig.c_translation.MacroArithmetic.div((count + __NCPUBITS) - @as(c_int, 1), __NCPUBITS) * @import("std").zig.c_translation.sizeof(__cpu_mask)) { + return @import("std").zig.c_translation.MacroArithmetic.div((count + __NCPUBITS) - @as(c_int, 1), __NCPUBITS) * @import("std").zig.c_translation.sizeof(__cpu_mask); +} +pub inline fn __CPU_ALLOC(count: anytype) @TypeOf(__sched_cpualloc(count)) { + return __sched_cpualloc(count); +} +pub inline fn __CPU_FREE(cpuset: anytype) @TypeOf(__sched_cpufree(cpuset)) { + return __sched_cpufree(cpuset); +} +pub const _BITS_SETJMP_H = @as(c_int, 1); +pub const __jmp_buf_tag_defined = @as(c_int, 1); +pub const PTHREAD_CANCELED = @import("std").zig.c_translation.cast(?*anyopaque, -@as(c_int, 1)); +pub const PTHREAD_ONCE_INIT = @as(c_int, 0); +pub const PTHREAD_BARRIER_SERIAL_THREAD = -@as(c_int, 1); +pub const __cleanup_fct_attribute = ""; +pub inline fn __sigsetjmp_cancel(env: anytype, savemask: anytype) @TypeOf(__sigsetjmp(@import("std").zig.c_translation.cast([*c]struct___jmp_buf_tag, @import("std").zig.c_translation.cast(?*anyopaque, env)), savemask)) { + return __sigsetjmp(@import("std").zig.c_translation.cast([*c]struct___jmp_buf_tag, @import("std").zig.c_translation.cast(?*anyopaque, env)), savemask); +} +pub const UV_THREADPOOL_H_ = ""; +pub const UV_LINUX_H = ""; +pub const UV_IO_PRIVATE_PLATFORM_FIELDS = ""; +pub const UV_PLATFORM_SEM_T = sem_t; +pub const UV_STREAM_PRIVATE_PLATFORM_FIELDS = ""; +pub const UV_ONCE_INIT = PTHREAD_ONCE_INIT; +pub const HAVE_DIRENT_TYPES = ""; +pub const UV__DT_FILE = DT_REG; +pub const UV__DT_DIR = DT_DIR; +pub const UV__DT_LINK = DT_LNK; +pub const UV__DT_FIFO = DT_FIFO; +pub const UV__DT_SOCKET = DT_SOCK; +pub const UV__DT_CHAR = DT_CHR; +pub const UV__DT_BLOCK = DT_BLK; +pub const UV_DYNAMIC = ""; +pub const UV_REQ_TYPE_PRIVATE = ""; +pub const UV_REQ_PRIVATE_FIELDS = ""; +pub const UV_PRIVATE_REQ_TYPES = ""; +pub const UV_SHUTDOWN_PRIVATE_FIELDS = ""; +pub const UV_TCP_PRIVATE_FIELDS = ""; +pub const UV_FS_O_APPEND = O_APPEND; +pub const UV_FS_O_CREAT = O_CREAT; +pub const UV_FS_O_DIRECT = @as(c_int, 0x04000); +pub const UV_FS_O_DIRECTORY = O_DIRECTORY; +pub const UV_FS_O_DSYNC = O_DSYNC; +pub const UV_FS_O_EXCL = O_EXCL; +pub const UV_FS_O_EXLOCK = @as(c_int, 0); +pub const UV_FS_O_NOATIME = @as(c_int, 0); +pub const UV_FS_O_NOCTTY = O_NOCTTY; +pub const UV_FS_O_NOFOLLOW = O_NOFOLLOW; +pub const UV_FS_O_NONBLOCK = O_NONBLOCK; +pub const UV_FS_O_RDONLY = O_RDONLY; +pub const UV_FS_O_RDWR = O_RDWR; +pub const UV_FS_O_SYMLINK = @as(c_int, 0); +pub const UV_FS_O_SYNC = O_SYNC; +pub const UV_FS_O_TRUNC = O_TRUNC; +pub const UV_FS_O_WRONLY = O_WRONLY; +pub const UV_FS_O_FILEMAP = @as(c_int, 0); +pub const UV_FS_O_RANDOM = @as(c_int, 0); +pub const UV_FS_O_SHORT_LIVED = @as(c_int, 0); +pub const UV_FS_O_SEQUENTIAL = @as(c_int, 0); +pub const UV_FS_O_TEMPORARY = @as(c_int, 0); +pub const UV_PRIORITY_LOW = @as(c_int, 19); +pub const UV_PRIORITY_BELOW_NORMAL = @as(c_int, 10); +pub const UV_PRIORITY_NORMAL = @as(c_int, 0); +pub const UV_PRIORITY_ABOVE_NORMAL = -@as(c_int, 7); +pub const UV_PRIORITY_HIGH = -@as(c_int, 14); +pub const UV_PRIORITY_HIGHEST = -@as(c_int, 20); +pub const UV_MAXHOSTNAMESIZE = MAXHOSTNAMELEN + @as(c_int, 1); +pub const UV_FS_COPYFILE_EXCL = @as(c_int, 0x0001); +pub const UV_FS_COPYFILE_FICLONE = @as(c_int, 0x0002); +pub const UV_FS_COPYFILE_FICLONE_FORCE = @as(c_int, 0x0004); +pub const UV_FS_SYMLINK_DIR = @as(c_int, 0x0001); +pub const UV_FS_SYMLINK_JUNCTION = @as(c_int, 0x0002); +pub const UV_IF_NAMESIZE = @as(c_int, 16) + @as(c_int, 1); +pub const FILE_ID_EMPTY = @import("std").mem.zeroInit(FileID, .{ + .inode = @as(c_int, 0), + .device_id = @as(c_int, 0), +}); +pub const NODE_NORMAL = @as(c_int, 0); +pub const NODE_WRITABLE = @as(c_int, 1); +pub const NODE_OTHER = @as(c_int, 2); +pub const NVIM_REGEXP_DEFS_H = ""; +pub const NSUBEXP = @as(c_int, 10); +pub const NFA_MAX_BRACES = @as(c_int, 20); +pub const NFA_MAX_STATES = @import("std").zig.c_translation.promoteIntLiteral(c_int, 100000, .decimal); +pub const NFA_TOO_EXPENSIVE = -@as(c_int, 1); +pub const AUTOMATIC_ENGINE = @as(c_int, 0); +pub const BACKTRACKING_ENGINE = @as(c_int, 1); +pub const NFA_ENGINE = @as(c_int, 2); +pub const REGSUB_COPY = @as(c_int, 1); +pub const REGSUB_MAGIC = @as(c_int, 2); +pub const REGSUB_BACKSLASH = @as(c_int, 4); +pub const NVIM_SYNTAX_DEFS_H = ""; +pub const SST_MIN_ENTRIES = @as(c_int, 150); +pub const SST_MAX_ENTRIES = @as(c_int, 1000); +pub const SST_FIX_STATES = @as(c_int, 7); +pub const SST_DIST = @as(c_int, 16); +pub const SST_INVALID = @import("std").zig.c_translation.cast([*c]synstate_T, -@as(c_int, 1)); +pub const NVIM_TERMINAL_H = ""; +pub inline fn ALIST(win: anytype) @TypeOf(win.*.w_alist) { + return win.*.w_alist; +} +pub const GARGLIST = @import("std").zig.c_translation.cast([*c]aentry_T, global_alist.al_ga.ga_data); +pub const ARGLIST = @import("std").zig.c_translation.cast([*c]aentry_T, ALIST(curwin).*.al_ga.ga_data); +pub inline fn WARGLIST(wp: anytype) [*c]aentry_T { + return @import("std").zig.c_translation.cast([*c]aentry_T, ALIST(wp).*.al_ga.ga_data); +} +pub inline fn AARGLIST(al: anytype) [*c]aentry_T { + return @import("std").zig.c_translation.cast([*c]aentry_T, al.*.al_ga.ga_data); +} +pub const GARGCOUNT = global_alist.al_ga.ga_len; +pub const ARGCOUNT = ALIST(curwin).*.al_ga.ga_len; +pub inline fn WARGCOUNT(wp: anytype) @TypeOf(ALIST(wp).*.al_ga.ga_len) { + return ALIST(wp).*.al_ga.ga_len; +} +pub const SYNSPL_DEFAULT = @as(c_int, 0); +pub const SYNSPL_TOP = @as(c_int, 1); +pub const SYNSPL_NOTOP = @as(c_int, 2); +pub const SYNFLD_START = @as(c_int, 0); +pub const SYNFLD_MINIMUM = @as(c_int, 1); +pub inline fn B_SPELL(buf: anytype) @TypeOf(buf.*.b_spell) { + return buf.*.b_spell; +} +pub const SPO_CAMEL = @as(c_int, 0x1); +pub const SPO_NPBUFFER = @as(c_int, 0x2); +pub const BUF_HAS_QF_ENTRY = @as(c_int, 1); +pub const BUF_HAS_LL_ENTRY = @as(c_int, 2); +pub const MAX_MAPHASH = @as(c_int, 256); +pub const B_IMODE_USE_INSERT = -@as(c_int, 1); +pub const B_IMODE_NONE = @as(c_int, 0); +pub const B_IMODE_LMAP = @as(c_int, 1); +pub const B_IMODE_LAST = @as(c_int, 1); +pub const KEYMAP_INIT = @as(c_int, 1); +pub const KEYMAP_LOADED = @as(c_int, 2); +pub const DB_COUNT = @as(c_int, 8); +pub const SNAP_HELP_IDX = @as(c_int, 0); +pub const SNAP_AUCMD_IDX = @as(c_int, 1); +pub const SNAP_COUNT = @as(c_int, 2); +pub const FR_LEAF = @as(c_int, 0); +pub const FR_ROW = @as(c_int, 1); +pub const FR_COL = @as(c_int, 2); +pub inline fn GLOBAL_WO(p: anytype) @TypeOf(@import("std").zig.c_translation.cast([*c]u8, p) + @import("std").zig.c_translation.sizeof(winopt_T)) { + return @import("std").zig.c_translation.cast([*c]u8, p) + @import("std").zig.c_translation.sizeof(winopt_T); +} +pub const NVIM_API_COMMAND_H = ""; +pub const NVIM_DECORATION_H = ""; +pub const DECOR_PRIORITY_BASE = @as(c_int, 0x1000); +pub const VIRTTEXT_EMPTY = @import("std").zig.c_translation.cast(VirtText, KV_INITIAL_VALUE); +pub const NVIM_EX_CMDS_H = ""; +pub const NVIM_EX_CMDS_DEFS_H = ""; +pub const NVIM_NORMAL_H = ""; +pub const FIND_IDENT = @as(c_int, 1); +pub const FIND_STRING = @as(c_int, 2); +pub const FIND_EVAL = @as(c_int, 4); +pub const CA_COMMAND_BUSY = @as(c_int, 1); +pub const CA_NO_ADJ_OP_END = @as(c_int, 2); +pub const SHOWCMD_COLS = @as(c_int, 10); +pub const SHOWCMD_BUFLEN = (SHOWCMD_COLS + @as(c_int, 1)) + @as(c_int, 30); +pub const EX_RANGE = @as(c_uint, 0x001); +pub const EX_BANG = @as(c_uint, 0x002); +pub const EX_EXTRA = @as(c_uint, 0x004); +pub const EX_XFILE = @as(c_uint, 0x008); +pub const EX_NOSPC = @as(c_uint, 0x010); +pub const EX_DFLALL = @as(c_uint, 0x020); +pub const EX_WHOLEFOLD = @as(c_uint, 0x040); +pub const EX_NEEDARG = @as(c_uint, 0x080); +pub const EX_TRLBAR = @as(c_uint, 0x100); +pub const EX_REGSTR = @as(c_uint, 0x200); +pub const EX_COUNT = @as(c_uint, 0x400); +pub const EX_NOTRLCOM = @as(c_uint, 0x800); +pub const EX_ZEROR = @as(c_uint, 0x1000); +pub const EX_CTRLV = @as(c_uint, 0x2000); +pub const EX_CMDARG = @as(c_uint, 0x4000); +pub const EX_BUFNAME = @as(c_uint, 0x8000); +pub const EX_BUFUNL = @import("std").zig.c_translation.promoteIntLiteral(c_uint, 0x10000, .hexadecimal); +pub const EX_ARGOPT = @import("std").zig.c_translation.promoteIntLiteral(c_uint, 0x20000, .hexadecimal); +pub const EX_SBOXOK = @import("std").zig.c_translation.promoteIntLiteral(c_uint, 0x40000, .hexadecimal); +pub const EX_CMDWIN = @import("std").zig.c_translation.promoteIntLiteral(c_uint, 0x80000, .hexadecimal); +pub const EX_MODIFY = @import("std").zig.c_translation.promoteIntLiteral(c_uint, 0x100000, .hexadecimal); +pub const EX_FLAGS = @import("std").zig.c_translation.promoteIntLiteral(c_uint, 0x200000, .hexadecimal); +pub const EX_LOCK_OK = @import("std").zig.c_translation.promoteIntLiteral(c_uint, 0x1000000, .hexadecimal); +pub const EX_KEEPSCRIPT = @import("std").zig.c_translation.promoteIntLiteral(c_uint, 0x4000000, .hexadecimal); +pub const EX_PREVIEW = @import("std").zig.c_translation.promoteIntLiteral(c_uint, 0x8000000, .hexadecimal); +pub const EX_FILES = EX_XFILE | EX_EXTRA; +pub const EX_FILE1 = EX_FILES | EX_NOSPC; +pub const EX_WORD1 = EX_EXTRA | EX_NOSPC; +pub const BAD_REPLACE = '?'; +pub const BAD_KEEP = -@as(c_int, 1); +pub const BAD_DROP = -@as(c_int, 2); +pub const FORCE_BIN = @as(c_int, 1); +pub const FORCE_NOBIN = @as(c_int, 2); +pub const EXFLAG_LIST = @as(c_int, 0x01); +pub const EXFLAG_NR = @as(c_int, 0x02); +pub const EXFLAG_PRINT = @as(c_int, 0x04); +pub const EXPAND_BUF_LEN = @as(c_int, 256); +pub const XP_BS_NONE = @as(c_int, 0); +pub const XP_BS_ONE = @as(c_int, 1); +pub const XP_BS_THREE = @as(c_int, 2); +pub const ECMD_HIDE = @as(c_int, 0x01); +pub const ECMD_SET_HELP = @as(c_int, 0x02); +pub const ECMD_OLDBUF = @as(c_int, 0x04); +pub const ECMD_FORCEIT = @as(c_int, 0x08); +pub const ECMD_ADDBUF = @as(c_int, 0x10); +pub const ECMD_ALTBUF = @as(c_int, 0x20); +pub const ECMD_NOWINENTER = @as(c_int, 0x40); +pub const ECMD_LASTL = @import("std").zig.c_translation.cast(linenr_T, @as(c_int, 0)); +pub const ECMD_LAST = @import("std").zig.c_translation.cast(linenr_T, -@as(c_int, 1)); +pub const ECMD_ONE = @import("std").zig.c_translation.cast(linenr_T, @as(c_int, 1)); +pub const NVIM_API_DEPRECATED_H = ""; +pub const NVIM_API_EXTMARK_H = ""; +pub const NVIM_API_OPTIONS_H = ""; +pub const NVIM_API_TABPAGE_H = ""; +pub const NVIM_API_UI_H = ""; +pub const NVIM_UI_H = ""; +pub const NVIM_EVENT_MULTIQUEUE_H = ""; +pub const NVIM_EVENT_DEFS_H = ""; +pub const EVENT_HANDLER_MAX_ARGC = @as(c_int, 10); +pub const NVIM_GLOBALS_H = ""; +pub const NVIM_ASCII_H = ""; +pub inline fn CHAR_ORD(x: anytype) @TypeOf(if (@import("std").zig.c_translation.cast(u8, x) < 'a') @import("std").zig.c_translation.cast(u8, x) - 'A' else @import("std").zig.c_translation.cast(u8, x) - 'a') { + return if (@import("std").zig.c_translation.cast(u8, x) < 'a') @import("std").zig.c_translation.cast(u8, x) - 'A' else @import("std").zig.c_translation.cast(u8, x) - 'a'; +} +pub inline fn CHAR_ORD_LOW(x: anytype) @TypeOf(@import("std").zig.c_translation.cast(u8, x) - 'a') { + return @import("std").zig.c_translation.cast(u8, x) - 'a'; +} +pub inline fn CHAR_ORD_UP(x: anytype) @TypeOf(@import("std").zig.c_translation.cast(u8, x) - 'A') { + return @import("std").zig.c_translation.cast(u8, x) - 'A'; +} +pub inline fn ROT13(c: anytype, a: anytype) @TypeOf(@import("std").zig.c_translation.MacroArithmetic.rem((c - a) + @as(c_int, 13), @as(c_int, 26)) + a) { + return @import("std").zig.c_translation.MacroArithmetic.rem((c - a) + @as(c_int, 13), @as(c_int, 26)) + a; +} +pub const NUL = '\x00'; +pub const BELL = '\x07'; +pub const BS = '\x08'; +pub const TAB = '\x09'; +pub const NL = '\x0a'; +pub const NL_STR = "\x0a"; +pub const FF = '\x0c'; +pub const CAR = '\x0d'; +pub const ESC = '\x1b'; +pub const ESC_STR = "\x1b"; +pub const DEL = @as(c_int, 0x7f); +pub const DEL_STR = "\x7f"; +pub const CSI = @as(c_int, 0x9b); +pub const CSI_STR = "\x9b"; +pub const DCS = @as(c_int, 0x90); +pub const STERM = @as(c_int, 0x9c); +pub const POUND = @as(c_int, 0xA3); +pub inline fn CTRL_CHR(x: anytype) @TypeOf(TOUPPER_ASC(x) ^ @as(c_int, 0x40)) { + return TOUPPER_ASC(x) ^ @as(c_int, 0x40); +} +pub inline fn META(x: anytype) @TypeOf(x | @as(c_int, 0x80)) { + return x | @as(c_int, 0x80); +} +pub const CTRL_F_STR = "\x06"; +pub const CTRL_H_STR = "\x08"; +pub const CTRL_V_STR = "\x16"; +pub const Ctrl_AT = @as(c_int, 0); +pub const Ctrl_A = @as(c_int, 1); +pub const Ctrl_B = @as(c_int, 2); +pub const Ctrl_C = @as(c_int, 3); +pub const Ctrl_D = @as(c_int, 4); +pub const Ctrl_E = @as(c_int, 5); +pub const Ctrl_F = @as(c_int, 6); +pub const Ctrl_G = @as(c_int, 7); +pub const Ctrl_H = @as(c_int, 8); +pub const Ctrl_I = @as(c_int, 9); +pub const Ctrl_J = @as(c_int, 10); +pub const Ctrl_K = @as(c_int, 11); +pub const Ctrl_L = @as(c_int, 12); +pub const Ctrl_M = @as(c_int, 13); +pub const Ctrl_N = @as(c_int, 14); +pub const Ctrl_O = @as(c_int, 15); +pub const Ctrl_P = @as(c_int, 16); +pub const Ctrl_Q = @as(c_int, 17); +pub const Ctrl_R = @as(c_int, 18); +pub const Ctrl_S = @as(c_int, 19); +pub const Ctrl_T = @as(c_int, 20); +pub const Ctrl_U = @as(c_int, 21); +pub const Ctrl_V = @as(c_int, 22); +pub const Ctrl_W = @as(c_int, 23); +pub const Ctrl_X = @as(c_int, 24); +pub const Ctrl_Y = @as(c_int, 25); +pub const Ctrl_Z = @as(c_int, 26); +pub const Ctrl_BSL = @as(c_int, 28); +pub const Ctrl_RSB = @as(c_int, 29); +pub const Ctrl_HAT = @as(c_int, 30); +pub const Ctrl__ = @as(c_int, 31); +pub const PATHSEP = '/'; +pub const PATHSEPSTR = "/"; +pub const NVIM_EVENT_LOOP_H = ""; +pub const _AC_KLIST_H = ""; +pub inline fn kl_val(iter: anytype) @TypeOf(iter.*.data) { + return iter.*.data; +} +pub inline fn kl_next(iter: anytype) @TypeOf(iter.*.next) { + return iter.*.next; +} +pub inline fn kl_begin(kl: anytype) @TypeOf(kl.*.head) { + return kl.*.head; +} +pub inline fn kl_end(kl: anytype) @TypeOf(kl.*.tail) { + return kl.*.tail; +} +pub inline fn kl_shift(name: anytype, kl: anytype) @TypeOf(kl_shift_at(name, kl, &kl.*.head)) { + return kl_shift_at(name, kl, &kl.*.head); +} +pub inline fn kl_empty(kl: anytype) @TypeOf(kl.*.size == @as(c_int, 0)) { + return kl.*.size == @as(c_int, 0); +} +pub inline fn kl_iter(name: anytype, kl: anytype, p: anytype) @TypeOf(kl_iter_at(name, kl, p, NULL)) { + return kl_iter_at(name, kl, p, NULL); +} +pub const NVIM_EX_EVAL_DEFS_H = ""; +pub const NVIM_MBYTE_H = ""; +pub inline fn MB_BYTE2LEN(b: anytype) @TypeOf(utf8len_tab[@intCast(usize, b)]) { + return utf8len_tab[@intCast(usize, b)]; +} +pub inline fn MB_BYTE2LEN_CHECK(b: anytype) @TypeOf(if ((b < @as(c_int, 0)) or (b > @as(c_int, 255))) @as(c_int, 1) else utf8len_tab[@intCast(usize, b)]) { + return if ((b < @as(c_int, 0)) or (b > @as(c_int, 255))) @as(c_int, 1) else utf8len_tab[@intCast(usize, b)]; +} +pub const NVIM_MENU_DEFS_H = ""; +pub const MNU_HIDDEN_CHAR = ']'; +pub const NVIM_RUNTIME_H = ""; +pub const NVIM_AUTOCMD_H = ""; +pub const AUGROUP_DEFAULT = -@as(c_int, 1); +pub const AUGROUP_ERROR = -@as(c_int, 2); +pub const AUGROUP_ALL = -@as(c_int, 3); +pub const AUGROUP_DELETED = -@as(c_int, 4); +pub const BUFLOCAL_PAT_LEN = @as(c_int, 25); +pub const SOURCING_NAME = @import("std").zig.c_translation.cast([*c]estack_T, exestack.ga_data)[@intCast(usize, exestack.ga_len - @as(c_int, 1))].es_name; +pub const SOURCING_LNUM = @import("std").zig.c_translation.cast([*c]estack_T, exestack.ga_data)[@intCast(usize, exestack.ga_len - @as(c_int, 1))].es_lnum; +pub inline fn SCRIPT_ID_VALID(id: anytype) @TypeOf((id > @as(c_int, 0)) and (id <= script_items.ga_len)) { + return (id > @as(c_int, 0)) and (id <= script_items.ga_len); +} +pub const DOSO_NONE = @as(c_int, 0); +pub const DOSO_VIMRC = @as(c_int, 1); +pub const DIP_ALL = @as(c_int, 0x01); +pub const DIP_DIR = @as(c_int, 0x02); +pub const DIP_ERR = @as(c_int, 0x04); +pub const DIP_START = @as(c_int, 0x08); +pub const DIP_OPT = @as(c_int, 0x10); +pub const DIP_NORTP = @as(c_int, 0x20); +pub const DIP_NOAFTER = @as(c_int, 0x40); +pub const DIP_AFTER = @as(c_int, 0x80); +pub const DIP_DIRFILE = @as(c_int, 0x200); +pub const IOSIZE = @as(c_int, 1024) + @as(c_int, 1); +pub const MSG_BUF_LEN = @as(c_int, 480); +pub const MSG_BUF_CLEN = @import("std").zig.c_translation.MacroArithmetic.div(MSG_BUF_LEN, @as(c_int, 6)); +pub const _PATHSEPSTR = "/"; +pub const FILETYPE_FILE = "filetype.lua filetype.vim"; +pub const FTPLUGIN_FILE = "ftplugin.vim"; +pub const INDENT_FILE = "indent.vim"; +pub const FTOFF_FILE = "ftoff.vim"; +pub const FTPLUGOF_FILE = "ftplugof.vim"; +pub const INDOFF_FILE = "indoff.vim"; +pub const DFLT_ERRORFILE = "errors.err"; +pub const SYS_VIMRC_FILE = "$VIM" ++ _PATHSEPSTR ++ "sysinit.vim"; +pub const DFLT_HELPFILE = "$VIMRUNTIME" ++ _PATHSEPSTR ++ "doc" ++ _PATHSEPSTR ++ "help.txt"; +pub const SYNTAX_FNAME = "$VIMRUNTIME" ++ _PATHSEPSTR ++ "syntax" ++ _PATHSEPSTR ++ "%s.vim"; +pub const EXRC_FILE = ".exrc"; +pub const VIMRC_FILE = ".nvimrc"; +pub const VIMRC_LUA_FILE = ".nvim.lua"; +pub const NO_SCREEN = @as(c_int, 2); +pub const NO_BUFFERS = @as(c_int, 1); +pub const DFLT_COLS = @as(c_int, 80); +pub const DFLT_ROWS = @as(c_int, 24); +pub const vim_lseek = lseek; +pub const vim_ftell = ftello; +pub const vim_fseek = fseeko; +pub const globvarht = globvardict.dv_hashtab; +pub const PROF_NONE = @as(c_int, 0); +pub const PROF_YES = @as(c_int, 1); +pub const PROF_PAUSED = @as(c_int, 2); +pub const SID_MODELINE = -@as(c_int, 1); +pub const SID_CMDARG = -@as(c_int, 2); +pub const SID_CARG = -@as(c_int, 3); +pub const SID_ENV = -@as(c_int, 4); +pub const SID_ERROR = -@as(c_int, 5); +pub const SID_NONE = -@as(c_int, 6); +pub const SID_WINLAYOUT = -@as(c_int, 7); +pub const SID_LUA = -@as(c_int, 8); +pub const SID_API_CLIENT = -@as(c_int, 9); +pub const SID_STR = -@as(c_int, 10); +pub const ONE_WINDOW = firstwin == lastwin; +pub const aucmd_win = aucmd_win_vec.items; +pub const AUCMD_WIN_COUNT = @import("std").zig.c_translation.cast(c_int, aucmd_win_vec.size); +pub const DBCS_JPN = @as(c_int, 932); +pub const DBCS_JPNU = @as(c_int, 9932); +pub const DBCS_KOR = @as(c_int, 949); +pub const DBCS_KORU = @as(c_int, 9949); +pub const DBCS_CHS = @as(c_int, 936); +pub const DBCS_CHSU = @as(c_int, 9936); +pub const DBCS_CHT = @as(c_int, 950); +pub const DBCS_CHTU = @as(c_int, 9950); +pub const DBCS_2BYTE = @as(c_int, 1); +pub const DBCS_DEBUG = -@as(c_int, 1); +pub const SEA_NONE = @as(c_int, 0); +pub const SEA_DIALOG = @as(c_int, 1); +pub const SEA_QUIT = @as(c_int, 2); +pub const SEA_RECOVER = @as(c_int, 3); +pub const MODE_MAX_LENGTH = @as(c_int, 4); +pub const STL_IN_ICON = @as(c_int, 1); +pub const STL_IN_TITLE = @as(c_int, 2); +pub const MIN_CD_SCOPE = kCdScopeWindow; +pub const MAX_CD_SCOPE = kCdScopeGlobal; +pub const kUIGlobalCount = kUILinegrid; +pub const UI_BUF_SIZE = @as(c_int, 4096); +pub const EVENT_BUF_SIZE = @as(c_int, 256); +pub const NVIM_API_VIM_H = ""; +pub const NVIM_API_VIMSCRIPT_H = ""; +pub const NVIM_API_WIN_CONFIG_H = ""; +pub const NVIM_API_WINDOW_H = ""; +pub const NVIM_ARABIC_H = ""; +pub inline fn ARABIC_CHAR(ch: anytype) @TypeOf((ch & @import("std").zig.c_translation.promoteIntLiteral(c_int, 0xFF00, .hexadecimal)) == @as(c_int, 0x0600)) { + return (ch & @import("std").zig.c_translation.promoteIntLiteral(c_int, 0xFF00, .hexadecimal)) == @as(c_int, 0x0600); +} +pub const NVIM_ARGLIST_H = ""; +pub const NVIM_BUFFER_H = ""; +pub const NVIM_MEMLINE_H = ""; +pub const NVIM_BUFFER_UPDATES_H = ""; +pub const NVIM_EXTMARK_H = ""; +pub const NVIM_BUFWRITE_H = ""; +pub const NVIM_CHANGE_H = ""; +pub const OPENLINE_DELSPACES = @as(c_int, 0x01); +pub const OPENLINE_DO_COM = @as(c_int, 0x02); +pub const OPENLINE_KEEPTRAIL = @as(c_int, 0x04); +pub const OPENLINE_MARKFIX = @as(c_int, 0x08); +pub const OPENLINE_COM_LIST = @as(c_int, 0x10); +pub const OPENLINE_FORMAT = @as(c_int, 0x20); +pub const NVIM_CHANNEL_H = ""; +pub const NVIM_EVENT_LIBUV_PROCESS_H = ""; +pub const NVIM_EVENT_PROCESS_H = ""; +pub const NVIM_EVENT_RSTREAM_H = ""; +pub const NVIM_EVENT_STREAM_H = ""; +pub const NVIM_RBUFFER_H = ""; +pub const NVIM_EVENT_WSTREAM_H = ""; +pub const NVIM_EVENT_SOCKET_H = ""; +pub const ADDRESS_MAX_SIZE = @as(c_int, 256); +pub const NVIM_MAIN_H = ""; +pub const MAX_ARG_CMDS = @as(c_int, 10); +pub const NVIM_MSGPACK_RPC_CHANNEL_DEFS_H = ""; +pub const MSGPACK_UTIL_H = ""; +pub const MSGPACK_UNUSED = @import("std").zig.c_translation.Macros.DISCARD; +pub const MSGPACK_OBJECT_H = ""; +pub const MSGPACK_ZONE_H = ""; +pub const MSGPACK_SYSDEP_H = ""; +pub const MSGPACK_ENDIAN_BIG_BYTE = @as(c_int, 0); +pub const MSGPACK_ENDIAN_LITTLE_BYTE = @as(c_int, 1); +pub const MSGPACK_DLLEXPORT = ""; +pub const _BYTESWAP_H = @as(c_int, 1); +pub inline fn bswap_16(x: anytype) @TypeOf(__bswap_16(x)) { + return __bswap_16(x); +} +pub inline fn bswap_32(x: anytype) @TypeOf(__bswap_32(x)) { + return __bswap_32(x); +} +pub inline fn bswap_64(x: anytype) @TypeOf(__bswap_64(x)) { + return __bswap_64(x); +} +pub inline fn _msgpack_be16(x: anytype) @TypeOf(ntohs(@import("std").zig.c_translation.cast(u16, x))) { + return ntohs(@import("std").zig.c_translation.cast(u16, x)); +} +pub inline fn _msgpack_be32(x: anytype) @TypeOf(ntohl(@import("std").zig.c_translation.cast(u32, x))) { + return ntohl(@import("std").zig.c_translation.cast(u32, x)); +} +pub inline fn _msgpack_be64(x: anytype) @TypeOf(bswap_64(x)) { + return bswap_64(x); +} +pub const MSGPACK_ZONE_CHUNK_SIZE = @as(c_int, 8192); +pub const MSGPACK_ZONE_ALIGN = @import("std").zig.c_translation.sizeof(?*anyopaque); +pub const MSGPACK_PACK_H = ""; +pub const MSGPACK_PACK_DEFINE_H = ""; +pub const MSGPACK_TIMESTAMP_H = ""; +pub inline fn TAKE8_8(d: anytype) @TypeOf(@import("std").zig.c_translation.cast([*c]u8, &d)[@intCast(usize, @as(c_int, 0))]) { + return @import("std").zig.c_translation.cast([*c]u8, &d)[@intCast(usize, @as(c_int, 0))]; +} +pub inline fn TAKE8_16(d: anytype) @TypeOf(@import("std").zig.c_translation.cast([*c]u8, &d)[@intCast(usize, @as(c_int, 0))]) { + return @import("std").zig.c_translation.cast([*c]u8, &d)[@intCast(usize, @as(c_int, 0))]; +} +pub inline fn TAKE8_32(d: anytype) @TypeOf(@import("std").zig.c_translation.cast([*c]u8, &d)[@intCast(usize, @as(c_int, 0))]) { + return @import("std").zig.c_translation.cast([*c]u8, &d)[@intCast(usize, @as(c_int, 0))]; +} +pub inline fn TAKE8_64(d: anytype) @TypeOf(@import("std").zig.c_translation.cast([*c]u8, &d)[@intCast(usize, @as(c_int, 0))]) { + return @import("std").zig.c_translation.cast([*c]u8, &d)[@intCast(usize, @as(c_int, 0))]; +} +pub const MSGPACK_UNPACKER_H = ""; +pub const MSGPACK_UNPACKER_INIT_BUFFER_SIZE = @as(c_int, 64) * @as(c_int, 1024); +pub const MSGPACK_UNPACKER_RESERVE_SIZE = @as(c_int, 32) * @as(c_int, 1024); +pub const MSGPACK_SBUFFER_H = ""; +pub const MSGPACK_SBUFFER_INIT_SIZE = @as(c_int, 8192); +pub const MSGPACK_VREFBUFFER_H = ""; +pub const _SYS_UIO_H = @as(c_int, 1); +pub const _BITS_UIO_LIM_H = @as(c_int, 1); +pub const __IOV_MAX = @as(c_int, 1024); +pub const UIO_MAXIOV = __IOV_MAX; +pub const MSGPACK_VREFBUFFER_REF_SIZE = @as(c_int, 32); +pub const MSGPACK_VREFBUFFER_CHUNK_SIZE = @as(c_int, 8192); +pub const MSGPACK_VERSION_H = ""; +pub const MSGPACK_VERSION_MAJOR = @as(c_int, 5); +pub const MSGPACK_VERSION_MINOR = @as(c_int, 0); +pub const MSGPACK_VERSION_REVISION = @as(c_int, 0); +pub const MSGPACK_VERSION = MSGPACK_VERSION_I(MSGPACK_VERSION_MAJOR, MSGPACK_VERSION_MINOR, MSGPACK_VERSION_REVISION); +pub const NVIM_API_PRIVATE_DISPATCH_H = ""; +pub inline fn api_free_keydict_context(x: anytype) @TypeOf(api_free_keydict(x, context_table)) { + return api_free_keydict(x, context_table); +} +pub inline fn api_free_keydict_set_decoration_provider(x: anytype) @TypeOf(api_free_keydict(x, set_decoration_provider_table)) { + return api_free_keydict(x, set_decoration_provider_table); +} +pub inline fn api_free_keydict_set_extmark(x: anytype) @TypeOf(api_free_keydict(x, set_extmark_table)) { + return api_free_keydict(x, set_extmark_table); +} +pub inline fn api_free_keydict_keymap(x: anytype) @TypeOf(api_free_keydict(x, keymap_table)) { + return api_free_keydict(x, keymap_table); +} +pub inline fn api_free_keydict_get_commands(x: anytype) @TypeOf(api_free_keydict(x, get_commands_table)) { + return api_free_keydict(x, get_commands_table); +} +pub inline fn api_free_keydict_user_command(x: anytype) @TypeOf(api_free_keydict(x, user_command_table)) { + return api_free_keydict(x, user_command_table); +} +pub inline fn api_free_keydict_float_config(x: anytype) @TypeOf(api_free_keydict(x, float_config_table)) { + return api_free_keydict(x, float_config_table); +} +pub inline fn api_free_keydict_runtime(x: anytype) @TypeOf(api_free_keydict(x, runtime_table)) { + return api_free_keydict(x, runtime_table); +} +pub inline fn api_free_keydict_eval_statusline(x: anytype) @TypeOf(api_free_keydict(x, eval_statusline_table)) { + return api_free_keydict(x, eval_statusline_table); +} +pub inline fn api_free_keydict_option(x: anytype) @TypeOf(api_free_keydict(x, option_table)) { + return api_free_keydict(x, option_table); +} +pub inline fn api_free_keydict_highlight(x: anytype) @TypeOf(api_free_keydict(x, highlight_table)) { + return api_free_keydict(x, highlight_table); +} +pub inline fn api_free_keydict_highlight_cterm(x: anytype) @TypeOf(api_free_keydict(x, highlight_cterm_table)) { + return api_free_keydict(x, highlight_cterm_table); +} +pub inline fn api_free_keydict_get_highlight(x: anytype) @TypeOf(api_free_keydict(x, get_highlight_table)) { + return api_free_keydict(x, get_highlight_table); +} +pub inline fn api_free_keydict_clear_autocmds(x: anytype) @TypeOf(api_free_keydict(x, clear_autocmds_table)) { + return api_free_keydict(x, clear_autocmds_table); +} +pub inline fn api_free_keydict_create_autocmd(x: anytype) @TypeOf(api_free_keydict(x, create_autocmd_table)) { + return api_free_keydict(x, create_autocmd_table); +} +pub inline fn api_free_keydict_exec_autocmds(x: anytype) @TypeOf(api_free_keydict(x, exec_autocmds_table)) { + return api_free_keydict(x, exec_autocmds_table); +} +pub inline fn api_free_keydict_get_autocmds(x: anytype) @TypeOf(api_free_keydict(x, get_autocmds_table)) { + return api_free_keydict(x, get_autocmds_table); +} +pub inline fn api_free_keydict_create_augroup(x: anytype) @TypeOf(api_free_keydict(x, create_augroup_table)) { + return api_free_keydict(x, create_augroup_table); +} +pub inline fn api_free_keydict_cmd(x: anytype) @TypeOf(api_free_keydict(x, cmd_table)) { + return api_free_keydict(x, cmd_table); +} +pub inline fn api_free_keydict_cmd_magic(x: anytype) @TypeOf(api_free_keydict(x, cmd_magic_table)) { + return api_free_keydict(x, cmd_magic_table); +} +pub inline fn api_free_keydict_cmd_mods(x: anytype) @TypeOf(api_free_keydict(x, cmd_mods_table)) { + return api_free_keydict(x, cmd_mods_table); +} +pub inline fn api_free_keydict_cmd_mods_filter(x: anytype) @TypeOf(api_free_keydict(x, cmd_mods_filter_table)) { + return api_free_keydict(x, cmd_mods_filter_table); +} +pub inline fn api_free_keydict_cmd_opts(x: anytype) @TypeOf(api_free_keydict(x, cmd_opts_table)) { + return api_free_keydict(x, cmd_opts_table); +} +pub inline fn api_free_keydict_echo_opts(x: anytype) @TypeOf(api_free_keydict(x, echo_opts_table)) { + return api_free_keydict(x, echo_opts_table); +} +pub inline fn api_free_keydict_exec_opts(x: anytype) @TypeOf(api_free_keydict(x, exec_opts_table)) { + return api_free_keydict(x, exec_opts_table); +} +pub const NVIM_VIM_H = ""; +pub const SESSION_FILE = "Session.vim"; +pub const MAX_MSG_HIST_LEN = @as(c_int, 200); +pub const SYS_OPTWIN_FILE = "$VIMRUNTIME/optwin.vim"; +pub const RUNTIME_DIRNAME = "runtime"; +pub const HAVE_PATHDEF = ""; +pub const MAX_TYPENR = @import("std").zig.c_translation.promoteIntLiteral(c_int, 65535, .decimal); +pub const ROOT_UID = @as(c_int, 0); +pub const NVIM_KEYCODES_H = ""; +pub const NVIM_STRINGS_H = ""; +pub const K_NUL = @as(c_int, 0xce); +pub const K_SPECIAL = @as(c_int, 0x80); +pub inline fn IS_SPECIAL(c: anytype) @TypeOf(c < @as(c_int, 0)) { + return c < @as(c_int, 0); +} +pub const ABBR_OFF = @as(c_int, 0x100); +pub const KS_ZERO = @as(c_int, 255); +pub const KS_SPECIAL = @as(c_int, 254); +pub const KS_EXTRA = @as(c_int, 253); +pub const KS_MODIFIER = @as(c_int, 252); +pub const KS_MOUSE = @as(c_int, 251); +pub const KS_MENU = @as(c_int, 250); +pub const KS_VER_SCROLLBAR = @as(c_int, 249); +pub const KS_HOR_SCROLLBAR = @as(c_int, 248); +pub const KS_SELECT = @as(c_int, 245); +pub const K_SELECT_STRING = "\x80\xf5X"; +pub const KS_KEY = @as(c_int, 242); +pub const KS_TABLINE = @as(c_int, 240); +pub const KS_TABMENU = @as(c_int, 239); +pub const KE_FILLER = 'X'; +pub inline fn TERMCAP2KEY(a: anytype, b: anytype) @TypeOf(-(a + (@import("std").zig.c_translation.cast(c_int, b) << @as(c_int, 8)))) { + return -(a + (@import("std").zig.c_translation.cast(c_int, b) << @as(c_int, 8))); +} +pub inline fn KEY2TERMCAP0(x: anytype) @TypeOf(-x & @as(c_int, 0xff)) { + return -x & @as(c_int, 0xff); +} +pub inline fn KEY2TERMCAP1(x: anytype) @TypeOf((@import("std").zig.c_translation.cast(c_uint, -x) >> @as(c_int, 8)) & @as(c_int, 0xff)) { + return (@import("std").zig.c_translation.cast(c_uint, -x) >> @as(c_int, 8)) & @as(c_int, 0xff); +} +pub inline fn K_SECOND(c: anytype) @TypeOf(if (c == K_SPECIAL) KS_SPECIAL else if (c == NUL) KS_ZERO else KEY2TERMCAP0(c)) { + return if (c == K_SPECIAL) KS_SPECIAL else if (c == NUL) KS_ZERO else KEY2TERMCAP0(c); +} +pub inline fn K_THIRD(c: anytype) @TypeOf(if ((c == K_SPECIAL) or (c == NUL)) KE_FILLER else KEY2TERMCAP1(c)) { + return if ((c == K_SPECIAL) or (c == NUL)) KE_FILLER else KEY2TERMCAP1(c); +} +pub inline fn TO_SPECIAL(a: anytype, b: anytype) @TypeOf(if (a == KS_SPECIAL) K_SPECIAL else if (a == KS_ZERO) K_ZERO else TERMCAP2KEY(a, b)) { + return if (a == KS_SPECIAL) K_SPECIAL else if (a == KS_ZERO) K_ZERO else TERMCAP2KEY(a, b); +} +pub const K_ZERO = TERMCAP2KEY(KS_ZERO, KE_FILLER); +pub const K_UP = TERMCAP2KEY('k', 'u'); +pub const K_KUP = TERMCAP2KEY('K', 'u'); +pub const K_DOWN = TERMCAP2KEY('k', 'd'); +pub const K_KDOWN = TERMCAP2KEY('K', 'd'); +pub const K_LEFT = TERMCAP2KEY('k', 'l'); +pub const K_KLEFT = TERMCAP2KEY('K', 'l'); +pub const K_RIGHT = TERMCAP2KEY('k', 'r'); +pub const K_KRIGHT = TERMCAP2KEY('K', 'r'); +pub const K_S_UP = TERMCAP2KEY(KS_EXTRA, KE_S_UP); +pub const K_S_DOWN = TERMCAP2KEY(KS_EXTRA, KE_S_DOWN); +pub const K_S_LEFT = TERMCAP2KEY('#', '4'); +pub const K_C_LEFT = TERMCAP2KEY(KS_EXTRA, KE_C_LEFT); +pub const K_S_RIGHT = TERMCAP2KEY('%', 'i'); +pub const K_C_RIGHT = TERMCAP2KEY(KS_EXTRA, KE_C_RIGHT); +pub const K_S_HOME = TERMCAP2KEY('#', '2'); +pub const K_C_HOME = TERMCAP2KEY(KS_EXTRA, KE_C_HOME); +pub const K_S_END = TERMCAP2KEY('*', '7'); +pub const K_C_END = TERMCAP2KEY(KS_EXTRA, KE_C_END); +pub const K_TAB = TERMCAP2KEY(KS_EXTRA, KE_TAB); +pub const K_S_TAB = TERMCAP2KEY('k', 'B'); +pub const K_XF1 = TERMCAP2KEY(KS_EXTRA, KE_XF1); +pub const K_XF2 = TERMCAP2KEY(KS_EXTRA, KE_XF2); +pub const K_XF3 = TERMCAP2KEY(KS_EXTRA, KE_XF3); +pub const K_XF4 = TERMCAP2KEY(KS_EXTRA, KE_XF4); +pub const K_XUP = TERMCAP2KEY(KS_EXTRA, KE_XUP); +pub const K_XDOWN = TERMCAP2KEY(KS_EXTRA, KE_XDOWN); +pub const K_XLEFT = TERMCAP2KEY(KS_EXTRA, KE_XLEFT); +pub const K_XRIGHT = TERMCAP2KEY(KS_EXTRA, KE_XRIGHT); +pub const K_F1 = TERMCAP2KEY('k', '1'); +pub const K_F2 = TERMCAP2KEY('k', '2'); +pub const K_F3 = TERMCAP2KEY('k', '3'); +pub const K_F4 = TERMCAP2KEY('k', '4'); +pub const K_F5 = TERMCAP2KEY('k', '5'); +pub const K_F6 = TERMCAP2KEY('k', '6'); +pub const K_F7 = TERMCAP2KEY('k', '7'); +pub const K_F8 = TERMCAP2KEY('k', '8'); +pub const K_F9 = TERMCAP2KEY('k', '9'); +pub const K_F10 = TERMCAP2KEY('k', ';'); +pub const K_F11 = TERMCAP2KEY('F', '1'); +pub const K_F12 = TERMCAP2KEY('F', '2'); +pub const K_F13 = TERMCAP2KEY('F', '3'); +pub const K_F14 = TERMCAP2KEY('F', '4'); +pub const K_F15 = TERMCAP2KEY('F', '5'); +pub const K_F16 = TERMCAP2KEY('F', '6'); +pub const K_F17 = TERMCAP2KEY('F', '7'); +pub const K_F18 = TERMCAP2KEY('F', '8'); +pub const K_F19 = TERMCAP2KEY('F', '9'); +pub const K_F20 = TERMCAP2KEY('F', 'A'); +pub const K_F21 = TERMCAP2KEY('F', 'B'); +pub const K_F22 = TERMCAP2KEY('F', 'C'); +pub const K_F23 = TERMCAP2KEY('F', 'D'); +pub const K_F24 = TERMCAP2KEY('F', 'E'); +pub const K_F25 = TERMCAP2KEY('F', 'F'); +pub const K_F26 = TERMCAP2KEY('F', 'G'); +pub const K_F27 = TERMCAP2KEY('F', 'H'); +pub const K_F28 = TERMCAP2KEY('F', 'I'); +pub const K_F29 = TERMCAP2KEY('F', 'J'); +pub const K_F30 = TERMCAP2KEY('F', 'K'); +pub const K_F31 = TERMCAP2KEY('F', 'L'); +pub const K_F32 = TERMCAP2KEY('F', 'M'); +pub const K_F33 = TERMCAP2KEY('F', 'N'); +pub const K_F34 = TERMCAP2KEY('F', 'O'); +pub const K_F35 = TERMCAP2KEY('F', 'P'); +pub const K_F36 = TERMCAP2KEY('F', 'Q'); +pub const K_F37 = TERMCAP2KEY('F', 'R'); +pub const K_F38 = TERMCAP2KEY('F', 'S'); +pub const K_F39 = TERMCAP2KEY('F', 'T'); +pub const K_F40 = TERMCAP2KEY('F', 'U'); +pub const K_F41 = TERMCAP2KEY('F', 'V'); +pub const K_F42 = TERMCAP2KEY('F', 'W'); +pub const K_F43 = TERMCAP2KEY('F', 'X'); +pub const K_F44 = TERMCAP2KEY('F', 'Y'); +pub const K_F45 = TERMCAP2KEY('F', 'Z'); +pub const K_F46 = TERMCAP2KEY('F', 'a'); +pub const K_F47 = TERMCAP2KEY('F', 'b'); +pub const K_F48 = TERMCAP2KEY('F', 'c'); +pub const K_F49 = TERMCAP2KEY('F', 'd'); +pub const K_F50 = TERMCAP2KEY('F', 'e'); +pub const K_F51 = TERMCAP2KEY('F', 'f'); +pub const K_F52 = TERMCAP2KEY('F', 'g'); +pub const K_F53 = TERMCAP2KEY('F', 'h'); +pub const K_F54 = TERMCAP2KEY('F', 'i'); +pub const K_F55 = TERMCAP2KEY('F', 'j'); +pub const K_F56 = TERMCAP2KEY('F', 'k'); +pub const K_F57 = TERMCAP2KEY('F', 'l'); +pub const K_F58 = TERMCAP2KEY('F', 'm'); +pub const K_F59 = TERMCAP2KEY('F', 'n'); +pub const K_F60 = TERMCAP2KEY('F', 'o'); +pub const K_F61 = TERMCAP2KEY('F', 'p'); +pub const K_F62 = TERMCAP2KEY('F', 'q'); +pub const K_F63 = TERMCAP2KEY('F', 'r'); +pub const K_S_XF1 = TERMCAP2KEY(KS_EXTRA, KE_S_XF1); +pub const K_S_XF2 = TERMCAP2KEY(KS_EXTRA, KE_S_XF2); +pub const K_S_XF3 = TERMCAP2KEY(KS_EXTRA, KE_S_XF3); +pub const K_S_XF4 = TERMCAP2KEY(KS_EXTRA, KE_S_XF4); +pub const K_S_F1 = TERMCAP2KEY(KS_EXTRA, KE_S_F1); +pub const K_S_F2 = TERMCAP2KEY(KS_EXTRA, KE_S_F2); +pub const K_S_F3 = TERMCAP2KEY(KS_EXTRA, KE_S_F3); +pub const K_S_F4 = TERMCAP2KEY(KS_EXTRA, KE_S_F4); +pub const K_S_F5 = TERMCAP2KEY(KS_EXTRA, KE_S_F5); +pub const K_S_F6 = TERMCAP2KEY(KS_EXTRA, KE_S_F6); +pub const K_S_F7 = TERMCAP2KEY(KS_EXTRA, KE_S_F7); +pub const K_S_F8 = TERMCAP2KEY(KS_EXTRA, KE_S_F8); +pub const K_S_F9 = TERMCAP2KEY(KS_EXTRA, KE_S_F9); +pub const K_S_F10 = TERMCAP2KEY(KS_EXTRA, KE_S_F10); +pub const K_S_F11 = TERMCAP2KEY(KS_EXTRA, KE_S_F11); +pub const K_S_F12 = TERMCAP2KEY(KS_EXTRA, KE_S_F12); +pub const K_HELP = TERMCAP2KEY('%', '1'); +pub const K_UNDO = TERMCAP2KEY('&', '8'); +pub const K_BS = TERMCAP2KEY('k', 'b'); +pub const K_INS = TERMCAP2KEY('k', 'I'); +pub const K_KINS = TERMCAP2KEY(KS_EXTRA, KE_KINS); +pub const K_DEL = TERMCAP2KEY('k', 'D'); +pub const K_KDEL = TERMCAP2KEY(KS_EXTRA, KE_KDEL); +pub const K_HOME = TERMCAP2KEY('k', 'h'); +pub const K_KHOME = TERMCAP2KEY('K', '1'); +pub const K_XHOME = TERMCAP2KEY(KS_EXTRA, KE_XHOME); +pub const K_ZHOME = TERMCAP2KEY(KS_EXTRA, KE_ZHOME); +pub const K_END = TERMCAP2KEY('@', '7'); +pub const K_KEND = TERMCAP2KEY('K', '4'); +pub const K_XEND = TERMCAP2KEY(KS_EXTRA, KE_XEND); +pub const K_ZEND = TERMCAP2KEY(KS_EXTRA, KE_ZEND); +pub const K_PAGEUP = TERMCAP2KEY('k', 'P'); +pub const K_PAGEDOWN = TERMCAP2KEY('k', 'N'); +pub const K_KPAGEUP = TERMCAP2KEY('K', '3'); +pub const K_KPAGEDOWN = TERMCAP2KEY('K', '5'); +pub const K_KORIGIN = TERMCAP2KEY('K', '2'); +pub const K_KPLUS = TERMCAP2KEY('K', '6'); +pub const K_KMINUS = TERMCAP2KEY('K', '7'); +pub const K_KDIVIDE = TERMCAP2KEY('K', '8'); +pub const K_KMULTIPLY = TERMCAP2KEY('K', '9'); +pub const K_KENTER = TERMCAP2KEY('K', 'A'); +pub const K_KPOINT = TERMCAP2KEY('K', 'B'); +pub const K_K0 = TERMCAP2KEY('K', 'C'); +pub const K_K1 = TERMCAP2KEY('K', 'D'); +pub const K_K2 = TERMCAP2KEY('K', 'E'); +pub const K_K3 = TERMCAP2KEY('K', 'F'); +pub const K_K4 = TERMCAP2KEY('K', 'G'); +pub const K_K5 = TERMCAP2KEY('K', 'H'); +pub const K_K6 = TERMCAP2KEY('K', 'I'); +pub const K_K7 = TERMCAP2KEY('K', 'J'); +pub const K_K8 = TERMCAP2KEY('K', 'K'); +pub const K_K9 = TERMCAP2KEY('K', 'L'); +pub const K_KCOMMA = TERMCAP2KEY('K', 'M'); +pub const K_KEQUAL = TERMCAP2KEY('K', 'N'); +pub const K_MOUSE = TERMCAP2KEY(KS_MOUSE, KE_FILLER); +pub const K_MENU = TERMCAP2KEY(KS_MENU, KE_FILLER); +pub const K_VER_SCROLLBAR = TERMCAP2KEY(KS_VER_SCROLLBAR, KE_FILLER); +pub const K_HOR_SCROLLBAR = TERMCAP2KEY(KS_HOR_SCROLLBAR, KE_FILLER); +pub const K_SELECT = TERMCAP2KEY(KS_SELECT, KE_FILLER); +pub const K_TABLINE = TERMCAP2KEY(KS_TABLINE, KE_FILLER); +pub const K_TABMENU = TERMCAP2KEY(KS_TABMENU, KE_FILLER); +pub const K_LEFTMOUSE = TERMCAP2KEY(KS_EXTRA, KE_LEFTMOUSE); +pub const K_LEFTMOUSE_NM = TERMCAP2KEY(KS_EXTRA, KE_LEFTMOUSE_NM); +pub const K_LEFTDRAG = TERMCAP2KEY(KS_EXTRA, KE_LEFTDRAG); +pub const K_LEFTRELEASE = TERMCAP2KEY(KS_EXTRA, KE_LEFTRELEASE); +pub const K_LEFTRELEASE_NM = TERMCAP2KEY(KS_EXTRA, KE_LEFTRELEASE_NM); +pub const K_MOUSEMOVE = TERMCAP2KEY(KS_EXTRA, KE_MOUSEMOVE); +pub const K_MIDDLEMOUSE = TERMCAP2KEY(KS_EXTRA, KE_MIDDLEMOUSE); +pub const K_MIDDLEDRAG = TERMCAP2KEY(KS_EXTRA, KE_MIDDLEDRAG); +pub const K_MIDDLERELEASE = TERMCAP2KEY(KS_EXTRA, KE_MIDDLERELEASE); +pub const K_RIGHTMOUSE = TERMCAP2KEY(KS_EXTRA, KE_RIGHTMOUSE); +pub const K_RIGHTDRAG = TERMCAP2KEY(KS_EXTRA, KE_RIGHTDRAG); +pub const K_RIGHTRELEASE = TERMCAP2KEY(KS_EXTRA, KE_RIGHTRELEASE); +pub const K_X1MOUSE = TERMCAP2KEY(KS_EXTRA, KE_X1MOUSE); +pub const K_X1DRAG = TERMCAP2KEY(KS_EXTRA, KE_X1DRAG); +pub const K_X1RELEASE = TERMCAP2KEY(KS_EXTRA, KE_X1RELEASE); +pub const K_X2MOUSE = TERMCAP2KEY(KS_EXTRA, KE_X2MOUSE); +pub const K_X2DRAG = TERMCAP2KEY(KS_EXTRA, KE_X2DRAG); +pub const K_X2RELEASE = TERMCAP2KEY(KS_EXTRA, KE_X2RELEASE); +pub const K_IGNORE = TERMCAP2KEY(KS_EXTRA, KE_IGNORE); +pub const K_NOP = TERMCAP2KEY(KS_EXTRA, KE_NOP); +pub const K_MOUSEDOWN = TERMCAP2KEY(KS_EXTRA, KE_MOUSEDOWN); +pub const K_MOUSEUP = TERMCAP2KEY(KS_EXTRA, KE_MOUSEUP); +pub const K_MOUSELEFT = TERMCAP2KEY(KS_EXTRA, KE_MOUSELEFT); +pub const K_MOUSERIGHT = TERMCAP2KEY(KS_EXTRA, KE_MOUSERIGHT); +pub const K_SNR = TERMCAP2KEY(KS_EXTRA, KE_SNR); +pub const K_PLUG = TERMCAP2KEY(KS_EXTRA, KE_PLUG); +pub const K_CMDWIN = TERMCAP2KEY(KS_EXTRA, KE_CMDWIN); +pub const K_DROP = TERMCAP2KEY(KS_EXTRA, KE_DROP); +pub const K_EVENT = TERMCAP2KEY(KS_EXTRA, KE_EVENT); +pub const K_COMMAND = TERMCAP2KEY(KS_EXTRA, KE_COMMAND); +pub const K_LUA = TERMCAP2KEY(KS_EXTRA, KE_LUA); +pub const MOD_MASK_SHIFT = @as(c_int, 0x02); +pub const MOD_MASK_CTRL = @as(c_int, 0x04); +pub const MOD_MASK_ALT = @as(c_int, 0x08); +pub const MOD_MASK_META = @as(c_int, 0x10); +pub const MOD_MASK_2CLICK = @as(c_int, 0x20); +pub const MOD_MASK_3CLICK = @as(c_int, 0x40); +pub const MOD_MASK_4CLICK = @as(c_int, 0x60); +pub const MOD_MASK_CMD = @as(c_int, 0x80); +pub const MOD_MASK_MULTI_CLICK = (MOD_MASK_2CLICK | MOD_MASK_3CLICK) | MOD_MASK_4CLICK; +pub const MAX_KEY_NAME_LEN = @as(c_int, 32); +pub const MAX_KEY_CODE_LEN = @as(c_int, 6); +pub const FLAG_CPO_BSLASH = @as(c_int, 0x01); +pub const CPO_TO_CPO_FLAGS = if (vim_strchr(@import("std").zig.c_translation.cast([*c]u8, p_cpo), CPO_BSLASH) == NULL) @as(c_int, 0) else FLAG_CPO_BSLASH; +pub const MSG_HIST = @as(c_int, 0x1000); +pub const MODE_NORMAL = @as(c_int, 0x01); +pub const MODE_VISUAL = @as(c_int, 0x02); +pub const MODE_OP_PENDING = @as(c_int, 0x04); +pub const MODE_CMDLINE = @as(c_int, 0x08); +pub const MODE_INSERT = @as(c_int, 0x10); +pub const MODE_LANGMAP = @as(c_int, 0x20); +pub const MODE_SELECT = @as(c_int, 0x40); +pub const MODE_TERMINAL = @as(c_int, 0x80); +pub const MAP_ALL_MODES = @as(c_int, 0xff); +pub const REPLACE_FLAG = @as(c_int, 0x100); +pub const MODE_REPLACE = REPLACE_FLAG | MODE_INSERT; +pub const VREPLACE_FLAG = @as(c_int, 0x200); +pub const MODE_VREPLACE = (REPLACE_FLAG | VREPLACE_FLAG) | MODE_INSERT; +pub const MODE_LREPLACE = REPLACE_FLAG | MODE_LANGMAP; +pub const MODE_NORMAL_BUSY = @as(c_int, 0x1000) | MODE_NORMAL; +pub const MODE_HITRETURN = @as(c_int, 0x2000) | MODE_NORMAL; +pub const MODE_ASKMORE = @as(c_int, 0x3000); +pub const MODE_SETWSIZE = @as(c_int, 0x4000); +pub const MODE_EXTERNCMD = @as(c_int, 0x5000); +pub const MODE_SHOWMATCH = @as(c_int, 0x6000) | MODE_INSERT; +pub const MODE_CONFIRM = @as(c_int, 0x7000); +pub const OK = @as(c_int, 1); +pub const FAIL = @as(c_int, 0); +pub const NOTDONE = @as(c_int, 2); +pub const VAR_TYPE_NUMBER = @as(c_int, 0); +pub const VAR_TYPE_STRING = @as(c_int, 1); +pub const VAR_TYPE_FUNC = @as(c_int, 2); +pub const VAR_TYPE_LIST = @as(c_int, 3); +pub const VAR_TYPE_DICT = @as(c_int, 4); +pub const VAR_TYPE_FLOAT = @as(c_int, 5); +pub const VAR_TYPE_BOOL = @as(c_int, 6); +pub const VAR_TYPE_SPECIAL = @as(c_int, 7); +pub const VAR_TYPE_BLOB = @as(c_int, 10); +pub const MIN_SWAP_PAGE_SIZE = @as(c_int, 1048); +pub const MAX_SWAP_PAGE_SIZE = @import("std").zig.c_translation.promoteIntLiteral(c_int, 50000, .decimal); +pub const STATUS_HEIGHT = @as(c_int, 1); +pub const QF_WINHEIGHT = @as(c_int, 10); +pub const LSIZE = @as(c_int, 512); +pub const DIALOG_MSG_SIZE = @as(c_int, 1000); +pub const MAXMAPLEN = @as(c_int, 50); +pub const UNDO_HASH_SIZE = @as(c_int, 32); +pub inline fn CLEAR_FIELD(field: anytype) @TypeOf(memset(&field, @as(c_int, 0), @import("std").zig.c_translation.sizeof(field))) { + return memset(&field, @as(c_int, 0), @import("std").zig.c_translation.sizeof(field)); +} +pub inline fn STRCPY(d: anytype, s: anytype) @TypeOf(strcpy(@import("std").zig.c_translation.cast([*c]u8, d), @import("std").zig.c_translation.cast([*c]u8, s))) { + return strcpy(@import("std").zig.c_translation.cast([*c]u8, d), @import("std").zig.c_translation.cast([*c]u8, s)); +} +pub inline fn STRICMP(d: anytype, s: anytype) @TypeOf(strcasecmp(@import("std").zig.c_translation.cast([*c]u8, d), @import("std").zig.c_translation.cast([*c]u8, s))) { + return strcasecmp(@import("std").zig.c_translation.cast([*c]u8, d), @import("std").zig.c_translation.cast([*c]u8, s)); +} +pub inline fn STRMOVE(d: anytype, s: anytype) @TypeOf(memmove(d, s, strlen(s) + @as(c_int, 1))) { + return memmove(d, s, strlen(s) + @as(c_int, 1)); +} +pub inline fn STRNICMP(d: anytype, s: anytype, n: anytype) @TypeOf(strncasecmp(@import("std").zig.c_translation.cast([*c]u8, d), @import("std").zig.c_translation.cast([*c]u8, s), @import("std").zig.c_translation.cast(usize, n))) { + return strncasecmp(@import("std").zig.c_translation.cast([*c]u8, d), @import("std").zig.c_translation.cast([*c]u8, s), @import("std").zig.c_translation.cast(usize, n)); +} +pub inline fn STRCAT(d: anytype, s: anytype) @TypeOf(strcat(@import("std").zig.c_translation.cast([*c]u8, d), @import("std").zig.c_translation.cast([*c]u8, s))) { + return strcat(@import("std").zig.c_translation.cast([*c]u8, d), @import("std").zig.c_translation.cast([*c]u8, s)); +} +pub const AUTOLOAD_CHAR = '#'; +pub inline fn PERROR(msg_1: anytype) anyopaque { + return @import("std").zig.c_translation.cast(anyopaque, semsg("%s: %s", msg_1, strerror(errno))); +} +pub const NVIM_PATH_H = ""; +pub const EW_DIR = @as(c_int, 0x01); +pub const EW_FILE = @as(c_int, 0x02); +pub const EW_NOTFOUND = @as(c_int, 0x04); +pub const EW_ADDSLASH = @as(c_int, 0x08); +pub const EW_KEEPALL = @as(c_int, 0x10); +pub const EW_SILENT = @as(c_int, 0x20); +pub const EW_EXEC = @as(c_int, 0x40); +pub const EW_PATH = @as(c_int, 0x80); +pub const EW_ICASE = @as(c_int, 0x100); +pub const EW_NOERROR = @as(c_int, 0x200); +pub const EW_NOTWILD = @as(c_int, 0x400); +pub const EW_KEEPDOLLAR = @as(c_int, 0x800); +pub const EW_ALLLINKS = @as(c_int, 0x1000); +pub const EW_SHELLCMD = @as(c_int, 0x2000); +pub const EW_DODOT = @as(c_int, 0x4000); +pub const EW_EMPTYOK = @import("std").zig.c_translation.promoteIntLiteral(c_int, 0x8000, .hexadecimal); +pub const EW_NOTENV = @import("std").zig.c_translation.promoteIntLiteral(c_int, 0x10000, .hexadecimal); +pub const EW_NOBREAK = @import("std").zig.c_translation.promoteIntLiteral(c_int, 0x20000, .hexadecimal); +pub inline fn HL_ATTR(n: anytype) @TypeOf(hl_attr_active[@intCast(usize, @import("std").zig.c_translation.cast(c_int, n))]) { + return hl_attr_active[@intCast(usize, @import("std").zig.c_translation.cast(c_int, n))]; +} +pub const MB_MAXBYTES = @as(c_int, 21); +pub inline fn os_errmsg(str: anytype) @TypeOf(fprintf(stderr, "%s", str)) { + return fprintf(stderr, "%s", str); +} +pub inline fn os_msg(str: anytype) @TypeOf(printf("%s", str)) { + return printf("%s", str); +} +pub const LOWEST_WIN_ID = @as(c_int, 1000); +pub const REPLACE_CR_NCHAR = -@as(c_int, 1); +pub const REPLACE_NL_NCHAR = -@as(c_int, 2); +pub const NVIM_OS_PTY_PROCESS_H = ""; +pub const NVIM_OS_PTY_PROCESS_UNIX_H = ""; +pub const _SYS_IOCTL_H = @as(c_int, 1); +pub const __ASM_GENERIC_IOCTLS_H = ""; +pub const _LINUX_IOCTL_H = ""; +pub const _ASM_GENERIC_IOCTL_H = ""; +pub const _IOC_NRBITS = @as(c_int, 8); +pub const _IOC_TYPEBITS = @as(c_int, 8); +pub const _IOC_SIZEBITS = @as(c_int, 14); +pub const _IOC_DIRBITS = @as(c_int, 2); +pub const _IOC_NRMASK = (@as(c_int, 1) << _IOC_NRBITS) - @as(c_int, 1); +pub const _IOC_TYPEMASK = (@as(c_int, 1) << _IOC_TYPEBITS) - @as(c_int, 1); +pub const _IOC_SIZEMASK = (@as(c_int, 1) << _IOC_SIZEBITS) - @as(c_int, 1); +pub const _IOC_DIRMASK = (@as(c_int, 1) << _IOC_DIRBITS) - @as(c_int, 1); +pub const _IOC_NRSHIFT = @as(c_int, 0); +pub const _IOC_TYPESHIFT = _IOC_NRSHIFT + _IOC_NRBITS; +pub const _IOC_SIZESHIFT = _IOC_TYPESHIFT + _IOC_TYPEBITS; +pub const _IOC_DIRSHIFT = _IOC_SIZESHIFT + _IOC_SIZEBITS; +pub const _IOC_NONE = @as(c_uint, 0); +pub const _IOC_WRITE = @as(c_uint, 1); +pub const _IOC_READ = @as(c_uint, 2); +pub inline fn _IOC(dir: anytype, @"type": anytype, nr: anytype, size: anytype) @TypeOf((((dir << _IOC_DIRSHIFT) | (@"type" << _IOC_TYPESHIFT)) | (nr << _IOC_NRSHIFT)) | (size << _IOC_SIZESHIFT)) { + return (((dir << _IOC_DIRSHIFT) | (@"type" << _IOC_TYPESHIFT)) | (nr << _IOC_NRSHIFT)) | (size << _IOC_SIZESHIFT); +} +pub inline fn _IOC_TYPECHECK(t: anytype) @TypeOf(@import("std").zig.c_translation.sizeof(t)) { + _ = @TypeOf(t); + return @import("std").zig.c_translation.sizeof(t); +} +pub inline fn _IO(@"type": anytype, nr: anytype) @TypeOf(_IOC(_IOC_NONE, @"type", nr, @as(c_int, 0))) { + return _IOC(_IOC_NONE, @"type", nr, @as(c_int, 0)); +} +pub inline fn _IOR(@"type": anytype, nr: anytype, size: anytype) @TypeOf(_IOC(_IOC_READ, @"type", nr, _IOC_TYPECHECK(size))) { + return _IOC(_IOC_READ, @"type", nr, _IOC_TYPECHECK(size)); +} +pub inline fn _IOW(@"type": anytype, nr: anytype, size: anytype) @TypeOf(_IOC(_IOC_WRITE, @"type", nr, _IOC_TYPECHECK(size))) { + return _IOC(_IOC_WRITE, @"type", nr, _IOC_TYPECHECK(size)); +} +pub inline fn _IOWR(@"type": anytype, nr: anytype, size: anytype) @TypeOf(_IOC(_IOC_READ | _IOC_WRITE, @"type", nr, _IOC_TYPECHECK(size))) { + return _IOC(_IOC_READ | _IOC_WRITE, @"type", nr, _IOC_TYPECHECK(size)); +} +pub inline fn _IOR_BAD(@"type": anytype, nr: anytype, size: anytype) @TypeOf(_IOC(_IOC_READ, @"type", nr, @import("std").zig.c_translation.sizeof(size))) { + _ = @TypeOf(size); + return _IOC(_IOC_READ, @"type", nr, @import("std").zig.c_translation.sizeof(size)); +} +pub inline fn _IOW_BAD(@"type": anytype, nr: anytype, size: anytype) @TypeOf(_IOC(_IOC_WRITE, @"type", nr, @import("std").zig.c_translation.sizeof(size))) { + _ = @TypeOf(size); + return _IOC(_IOC_WRITE, @"type", nr, @import("std").zig.c_translation.sizeof(size)); +} +pub inline fn _IOWR_BAD(@"type": anytype, nr: anytype, size: anytype) @TypeOf(_IOC(_IOC_READ | _IOC_WRITE, @"type", nr, @import("std").zig.c_translation.sizeof(size))) { + _ = @TypeOf(size); + return _IOC(_IOC_READ | _IOC_WRITE, @"type", nr, @import("std").zig.c_translation.sizeof(size)); +} +pub inline fn _IOC_DIR(nr: anytype) @TypeOf((nr >> _IOC_DIRSHIFT) & _IOC_DIRMASK) { + return (nr >> _IOC_DIRSHIFT) & _IOC_DIRMASK; +} +pub inline fn _IOC_TYPE(nr: anytype) @TypeOf((nr >> _IOC_TYPESHIFT) & _IOC_TYPEMASK) { + return (nr >> _IOC_TYPESHIFT) & _IOC_TYPEMASK; +} +pub inline fn _IOC_NR(nr: anytype) @TypeOf((nr >> _IOC_NRSHIFT) & _IOC_NRMASK) { + return (nr >> _IOC_NRSHIFT) & _IOC_NRMASK; +} +pub inline fn _IOC_SIZE(nr: anytype) @TypeOf((nr >> _IOC_SIZESHIFT) & _IOC_SIZEMASK) { + return (nr >> _IOC_SIZESHIFT) & _IOC_SIZEMASK; +} +pub const IOC_IN = _IOC_WRITE << _IOC_DIRSHIFT; +pub const IOC_OUT = _IOC_READ << _IOC_DIRSHIFT; +pub const IOC_INOUT = (_IOC_WRITE | _IOC_READ) << _IOC_DIRSHIFT; +pub const IOCSIZE_MASK = _IOC_SIZEMASK << _IOC_SIZESHIFT; +pub const IOCSIZE_SHIFT = _IOC_SIZESHIFT; +pub const TCGETS = @as(c_int, 0x5401); +pub const TCSETS = @as(c_int, 0x5402); +pub const TCSETSW = @as(c_int, 0x5403); +pub const TCSETSF = @as(c_int, 0x5404); +pub const TCGETA = @as(c_int, 0x5405); +pub const TCSETA = @as(c_int, 0x5406); +pub const TCSETAW = @as(c_int, 0x5407); +pub const TCSETAF = @as(c_int, 0x5408); +pub const TCSBRK = @as(c_int, 0x5409); +pub const TCXONC = @as(c_int, 0x540A); +pub const TCFLSH = @as(c_int, 0x540B); +pub const TIOCEXCL = @as(c_int, 0x540C); +pub const TIOCNXCL = @as(c_int, 0x540D); +pub const TIOCSCTTY = @as(c_int, 0x540E); +pub const TIOCGPGRP = @as(c_int, 0x540F); +pub const TIOCSPGRP = @as(c_int, 0x5410); +pub const TIOCOUTQ = @as(c_int, 0x5411); +pub const TIOCSTI = @as(c_int, 0x5412); +pub const TIOCGWINSZ = @as(c_int, 0x5413); +pub const TIOCSWINSZ = @as(c_int, 0x5414); +pub const TIOCMGET = @as(c_int, 0x5415); +pub const TIOCMBIS = @as(c_int, 0x5416); +pub const TIOCMBIC = @as(c_int, 0x5417); +pub const TIOCMSET = @as(c_int, 0x5418); +pub const TIOCGSOFTCAR = @as(c_int, 0x5419); +pub const TIOCSSOFTCAR = @as(c_int, 0x541A); +pub const FIONREAD = @as(c_int, 0x541B); +pub const TIOCINQ = FIONREAD; +pub const TIOCLINUX = @as(c_int, 0x541C); +pub const TIOCCONS = @as(c_int, 0x541D); +pub const TIOCGSERIAL = @as(c_int, 0x541E); +pub const TIOCSSERIAL = @as(c_int, 0x541F); +pub const TIOCPKT = @as(c_int, 0x5420); +pub const FIONBIO = @as(c_int, 0x5421); +pub const TIOCNOTTY = @as(c_int, 0x5422); +pub const TIOCSETD = @as(c_int, 0x5423); +pub const TIOCGETD = @as(c_int, 0x5424); +pub const TCSBRKP = @as(c_int, 0x5425); +pub const TIOCSBRK = @as(c_int, 0x5427); +pub const TIOCCBRK = @as(c_int, 0x5428); +pub const TIOCGSID = @as(c_int, 0x5429); +pub const TIOCGRS485 = @as(c_int, 0x542E); +pub const TIOCSRS485 = @as(c_int, 0x542F); +pub const TIOCGPTN = _IOR('T', @as(c_int, 0x30), c_uint); +pub const TIOCSPTLCK = _IOW('T', @as(c_int, 0x31), c_int); +pub const TIOCGDEV = _IOR('T', @as(c_int, 0x32), c_uint); +pub const TCGETX = @as(c_int, 0x5432); +pub const TCSETX = @as(c_int, 0x5433); +pub const TCSETXF = @as(c_int, 0x5434); +pub const TCSETXW = @as(c_int, 0x5435); +pub const TIOCSIG = _IOW('T', @as(c_int, 0x36), c_int); +pub const TIOCVHANGUP = @as(c_int, 0x5437); +pub const TIOCGPKT = _IOR('T', @as(c_int, 0x38), c_int); +pub const TIOCGPTLCK = _IOR('T', @as(c_int, 0x39), c_int); +pub const TIOCGEXCL = _IOR('T', @as(c_int, 0x40), c_int); +pub const TIOCGPTPEER = _IO('T', @as(c_int, 0x41)); +pub const FIONCLEX = @as(c_int, 0x5450); +pub const FIOCLEX = @as(c_int, 0x5451); +pub const FIOASYNC = @as(c_int, 0x5452); +pub const TIOCSERCONFIG = @as(c_int, 0x5453); +pub const TIOCSERGWILD = @as(c_int, 0x5454); +pub const TIOCSERSWILD = @as(c_int, 0x5455); +pub const TIOCGLCKTRMIOS = @as(c_int, 0x5456); +pub const TIOCSLCKTRMIOS = @as(c_int, 0x5457); +pub const TIOCSERGSTRUCT = @as(c_int, 0x5458); +pub const TIOCSERGETLSR = @as(c_int, 0x5459); +pub const TIOCSERGETMULTI = @as(c_int, 0x545A); +pub const TIOCSERSETMULTI = @as(c_int, 0x545B); +pub const TIOCMIWAIT = @as(c_int, 0x545C); +pub const TIOCGICOUNT = @as(c_int, 0x545D); +pub const FIOQSIZE = @as(c_int, 0x5460); +pub const TIOCPKT_DATA = @as(c_int, 0); +pub const TIOCPKT_FLUSHREAD = @as(c_int, 1); +pub const TIOCPKT_FLUSHWRITE = @as(c_int, 2); +pub const TIOCPKT_STOP = @as(c_int, 4); +pub const TIOCPKT_START = @as(c_int, 8); +pub const TIOCPKT_NOSTOP = @as(c_int, 16); +pub const TIOCPKT_DOSTOP = @as(c_int, 32); +pub const TIOCPKT_IOCTL = @as(c_int, 64); +pub const SIOCADDRT = @import("std").zig.c_translation.promoteIntLiteral(c_int, 0x890B, .hexadecimal); +pub const SIOCDELRT = @import("std").zig.c_translation.promoteIntLiteral(c_int, 0x890C, .hexadecimal); +pub const SIOCRTMSG = @import("std").zig.c_translation.promoteIntLiteral(c_int, 0x890D, .hexadecimal); +pub const SIOCGIFNAME = @import("std").zig.c_translation.promoteIntLiteral(c_int, 0x8910, .hexadecimal); +pub const SIOCSIFLINK = @import("std").zig.c_translation.promoteIntLiteral(c_int, 0x8911, .hexadecimal); +pub const SIOCGIFCONF = @import("std").zig.c_translation.promoteIntLiteral(c_int, 0x8912, .hexadecimal); +pub const SIOCGIFFLAGS = @import("std").zig.c_translation.promoteIntLiteral(c_int, 0x8913, .hexadecimal); +pub const SIOCSIFFLAGS = @import("std").zig.c_translation.promoteIntLiteral(c_int, 0x8914, .hexadecimal); +pub const SIOCGIFADDR = @import("std").zig.c_translation.promoteIntLiteral(c_int, 0x8915, .hexadecimal); +pub const SIOCSIFADDR = @import("std").zig.c_translation.promoteIntLiteral(c_int, 0x8916, .hexadecimal); +pub const SIOCGIFDSTADDR = @import("std").zig.c_translation.promoteIntLiteral(c_int, 0x8917, .hexadecimal); +pub const SIOCSIFDSTADDR = @import("std").zig.c_translation.promoteIntLiteral(c_int, 0x8918, .hexadecimal); +pub const SIOCGIFBRDADDR = @import("std").zig.c_translation.promoteIntLiteral(c_int, 0x8919, .hexadecimal); +pub const SIOCSIFBRDADDR = @import("std").zig.c_translation.promoteIntLiteral(c_int, 0x891a, .hexadecimal); +pub const SIOCGIFNETMASK = @import("std").zig.c_translation.promoteIntLiteral(c_int, 0x891b, .hexadecimal); +pub const SIOCSIFNETMASK = @import("std").zig.c_translation.promoteIntLiteral(c_int, 0x891c, .hexadecimal); +pub const SIOCGIFMETRIC = @import("std").zig.c_translation.promoteIntLiteral(c_int, 0x891d, .hexadecimal); +pub const SIOCSIFMETRIC = @import("std").zig.c_translation.promoteIntLiteral(c_int, 0x891e, .hexadecimal); +pub const SIOCGIFMEM = @import("std").zig.c_translation.promoteIntLiteral(c_int, 0x891f, .hexadecimal); +pub const SIOCSIFMEM = @import("std").zig.c_translation.promoteIntLiteral(c_int, 0x8920, .hexadecimal); +pub const SIOCGIFMTU = @import("std").zig.c_translation.promoteIntLiteral(c_int, 0x8921, .hexadecimal); +pub const SIOCSIFMTU = @import("std").zig.c_translation.promoteIntLiteral(c_int, 0x8922, .hexadecimal); +pub const SIOCSIFNAME = @import("std").zig.c_translation.promoteIntLiteral(c_int, 0x8923, .hexadecimal); +pub const SIOCSIFHWADDR = @import("std").zig.c_translation.promoteIntLiteral(c_int, 0x8924, .hexadecimal); +pub const SIOCGIFENCAP = @import("std").zig.c_translation.promoteIntLiteral(c_int, 0x8925, .hexadecimal); +pub const SIOCSIFENCAP = @import("std").zig.c_translation.promoteIntLiteral(c_int, 0x8926, .hexadecimal); +pub const SIOCGIFHWADDR = @import("std").zig.c_translation.promoteIntLiteral(c_int, 0x8927, .hexadecimal); +pub const SIOCGIFSLAVE = @import("std").zig.c_translation.promoteIntLiteral(c_int, 0x8929, .hexadecimal); +pub const SIOCSIFSLAVE = @import("std").zig.c_translation.promoteIntLiteral(c_int, 0x8930, .hexadecimal); +pub const SIOCADDMULTI = @import("std").zig.c_translation.promoteIntLiteral(c_int, 0x8931, .hexadecimal); +pub const SIOCDELMULTI = @import("std").zig.c_translation.promoteIntLiteral(c_int, 0x8932, .hexadecimal); +pub const SIOCGIFINDEX = @import("std").zig.c_translation.promoteIntLiteral(c_int, 0x8933, .hexadecimal); +pub const SIOGIFINDEX = SIOCGIFINDEX; +pub const SIOCSIFPFLAGS = @import("std").zig.c_translation.promoteIntLiteral(c_int, 0x8934, .hexadecimal); +pub const SIOCGIFPFLAGS = @import("std").zig.c_translation.promoteIntLiteral(c_int, 0x8935, .hexadecimal); +pub const SIOCDIFADDR = @import("std").zig.c_translation.promoteIntLiteral(c_int, 0x8936, .hexadecimal); +pub const SIOCSIFHWBROADCAST = @import("std").zig.c_translation.promoteIntLiteral(c_int, 0x8937, .hexadecimal); +pub const SIOCGIFCOUNT = @import("std").zig.c_translation.promoteIntLiteral(c_int, 0x8938, .hexadecimal); +pub const SIOCGIFBR = @import("std").zig.c_translation.promoteIntLiteral(c_int, 0x8940, .hexadecimal); +pub const SIOCSIFBR = @import("std").zig.c_translation.promoteIntLiteral(c_int, 0x8941, .hexadecimal); +pub const SIOCGIFTXQLEN = @import("std").zig.c_translation.promoteIntLiteral(c_int, 0x8942, .hexadecimal); +pub const SIOCSIFTXQLEN = @import("std").zig.c_translation.promoteIntLiteral(c_int, 0x8943, .hexadecimal); +pub const SIOCDARP = @import("std").zig.c_translation.promoteIntLiteral(c_int, 0x8953, .hexadecimal); +pub const SIOCGARP = @import("std").zig.c_translation.promoteIntLiteral(c_int, 0x8954, .hexadecimal); +pub const SIOCSARP = @import("std").zig.c_translation.promoteIntLiteral(c_int, 0x8955, .hexadecimal); +pub const SIOCDRARP = @import("std").zig.c_translation.promoteIntLiteral(c_int, 0x8960, .hexadecimal); +pub const SIOCGRARP = @import("std").zig.c_translation.promoteIntLiteral(c_int, 0x8961, .hexadecimal); +pub const SIOCSRARP = @import("std").zig.c_translation.promoteIntLiteral(c_int, 0x8962, .hexadecimal); +pub const SIOCGIFMAP = @import("std").zig.c_translation.promoteIntLiteral(c_int, 0x8970, .hexadecimal); +pub const SIOCSIFMAP = @import("std").zig.c_translation.promoteIntLiteral(c_int, 0x8971, .hexadecimal); +pub const SIOCADDDLCI = @import("std").zig.c_translation.promoteIntLiteral(c_int, 0x8980, .hexadecimal); +pub const SIOCDELDLCI = @import("std").zig.c_translation.promoteIntLiteral(c_int, 0x8981, .hexadecimal); +pub const SIOCDEVPRIVATE = @import("std").zig.c_translation.promoteIntLiteral(c_int, 0x89F0, .hexadecimal); +pub const SIOCPROTOPRIVATE = @import("std").zig.c_translation.promoteIntLiteral(c_int, 0x89E0, .hexadecimal); +pub const NCC = @as(c_int, 8); +pub const TIOCM_LE = @as(c_int, 0x001); +pub const TIOCM_DTR = @as(c_int, 0x002); +pub const TIOCM_RTS = @as(c_int, 0x004); +pub const TIOCM_ST = @as(c_int, 0x008); +pub const TIOCM_SR = @as(c_int, 0x010); +pub const TIOCM_CTS = @as(c_int, 0x020); +pub const TIOCM_CAR = @as(c_int, 0x040); +pub const TIOCM_RNG = @as(c_int, 0x080); +pub const TIOCM_DSR = @as(c_int, 0x100); +pub const TIOCM_CD = TIOCM_CAR; +pub const TIOCM_RI = TIOCM_RNG; +pub const N_TTY = @as(c_int, 0); +pub const N_SLIP = @as(c_int, 1); +pub const N_MOUSE = @as(c_int, 2); +pub const N_PPP = @as(c_int, 3); +pub const N_STRIP = @as(c_int, 4); +pub const N_AX25 = @as(c_int, 5); +pub const N_X25 = @as(c_int, 6); +pub const N_6PACK = @as(c_int, 7); +pub const N_MASC = @as(c_int, 8); +pub const N_R3964 = @as(c_int, 9); +pub const N_PROFIBUS_FDL = @as(c_int, 10); +pub const N_IRDA = @as(c_int, 11); +pub const N_SMSBLOCK = @as(c_int, 12); +pub const N_HDLC = @as(c_int, 13); +pub const N_SYNC_PPP = @as(c_int, 14); +pub const N_HCI = @as(c_int, 15); +pub const CHAN_STDIO = @as(c_int, 1); +pub const CHAN_STDERR = @as(c_int, 2); +pub const CALLBACK_READER_INIT = @import("std").mem.zeroInit(CallbackReader, .{ + .cb = CALLBACK_NONE, + .self = NULL, + .buffer = GA_EMPTY_INIT_VALUE, + .buffered = @"false", + .fwd_err = @"false", + .type = NULL, +}); +pub const NVIM_CHARSET_H = ""; +pub inline fn CH_FOLD(c: anytype) @TypeOf(utf_fold(if (@import("std").zig.c_translation.sizeof(c) == @import("std").zig.c_translation.sizeof(u8)) @import("std").zig.c_translation.cast(c_int, @import("std").zig.c_translation.cast(u8, c)) else @import("std").zig.c_translation.cast(c_int, c))) { + return utf_fold(if (@import("std").zig.c_translation.sizeof(c) == @import("std").zig.c_translation.sizeof(u8)) @import("std").zig.c_translation.cast(c_int, @import("std").zig.c_translation.cast(u8, c)) else @import("std").zig.c_translation.cast(c_int, c)); +} +pub const NVIM_CMDEXPAND_H = ""; +pub const NVIM_EX_GETLN_H = ""; +pub const NVIM_CMDHIST_H = ""; +pub const HIST_COUNT = HIST_DEBUG + @as(c_int, 1); +pub const NVIM_CONTEXT_H = ""; +pub const NVIM_CURSOR_H = ""; +pub const NVIM_CURSOR_SHAPE_H = ""; +pub const MSHAPE_NUMBERED = @as(c_int, 1000); +pub const MSHAPE_HIDE = @as(c_int, 1); +pub const SHAPE_MOUSE = @as(c_int, 1); +pub const SHAPE_CURSOR = @as(c_int, 2); +pub const NVIM_DEBUGGER_H = ""; +pub const NVIM_DECORATION_PROVIDER_H = ""; +pub const NVIM_DIFF_H = ""; +pub const NVIM_DIGRAPH_H = ""; +pub const NVIM_DRAWLINE_H = ""; +pub const NVIM_FOLD_H = ""; +pub const TERM_ATTRS_MAX = @as(c_int, 1024); +pub const NVIM_DRAWSCREEN_H = ""; +pub inline fn W_ENDCOL(wp: anytype) @TypeOf(wp.*.w_wincol + wp.*.w_width) { + return wp.*.w_wincol + wp.*.w_width; +} +pub inline fn W_ENDROW(wp: anytype) @TypeOf(wp.*.w_winrow + wp.*.w_height) { + return wp.*.w_winrow + wp.*.w_height; +} +pub const NVIM_EDIT_H = ""; +pub const KEY_OPEN_FORW = @as(c_int, 0x101); +pub const KEY_OPEN_BACK = @as(c_int, 0x102); +pub const KEY_COMPLETE = @as(c_int, 0x103); +pub const INDENT_SET = @as(c_int, 1); +pub const INDENT_INC = @as(c_int, 2); +pub const INDENT_DEC = @as(c_int, 3); +pub const BL_WHITE = @as(c_int, 1); +pub const BL_SOL = @as(c_int, 2); +pub const BL_FIX = @as(c_int, 4); +pub const INSCHAR_FORMAT = @as(c_int, 1); +pub const INSCHAR_DO_COM = @as(c_int, 2); +pub const INSCHAR_CTRLV = @as(c_int, 4); +pub const INSCHAR_NO_FEX = @as(c_int, 8); +pub const INSCHAR_COM_LIST = @as(c_int, 16); +pub const NVIM_EVENT_SIGNAL_H = ""; +pub const NVIM_EVENT_TIME_H = ""; +pub const NVIM_EX_CMDS2_H = ""; +pub const CCGD_AW = @as(c_int, 1); +pub const CCGD_MULTWIN = @as(c_int, 2); +pub const CCGD_FORCEIT = @as(c_int, 4); +pub const CCGD_ALLBUF = @as(c_int, 8); +pub const CCGD_EXCMD = @as(c_int, 16); +pub const NVIM_EX_DOCMD_H = ""; +pub const DOCMD_VERBOSE = @as(c_int, 0x01); +pub const DOCMD_NOWAIT = @as(c_int, 0x02); +pub const DOCMD_REPEAT = @as(c_int, 0x04); +pub const DOCMD_KEYTYPED = @as(c_int, 0x08); +pub const DOCMD_EXCRESET = @as(c_int, 0x10); +pub const DOCMD_KEEPLINE = @as(c_int, 0x20); +pub const VALID_PATH = @as(c_int, 1); +pub const VALID_HEAD = @as(c_int, 2); +pub inline fn IS_USER_CMDIDX(idx: anytype) @TypeOf(@import("std").zig.c_translation.cast(c_int, idx) < @as(c_int, 0)) { + return @import("std").zig.c_translation.cast(c_int, idx) < @as(c_int, 0); +} +pub const NVIM_EX_EVAL_H = ""; +pub const NVIM_EX_SESSION_H = ""; +pub const NVIM_FILE_SEARCH_H = ""; +pub const FINDFILE_FILE = @as(c_int, 0); +pub const FINDFILE_DIR = @as(c_int, 1); +pub const FINDFILE_BOTH = @as(c_int, 2); +pub const NVIM_FILEIO_H = ""; +pub const NVIM_OS_OS_H = ""; +pub const NVIM_OS_STDPATHS_DEFS_H = ""; +pub const ENV_LOGFILE = "NVIM_LOG_FILE"; +pub const ENV_NVIM = "NVIM"; +pub const READ_NEW = @as(c_int, 0x01); +pub const READ_FILTER = @as(c_int, 0x02); +pub const READ_STDIN = @as(c_int, 0x04); +pub const READ_BUFFER = @as(c_int, 0x08); +pub const READ_DUMMY = @as(c_int, 0x10); +pub const READ_KEEP_UNDO = @as(c_int, 0x20); +pub const READ_FIFO = @as(c_int, 0x40); +pub const READ_NOWINENTER = @as(c_int, 0x80); +pub const READ_NOFILE = @as(c_int, 0x100); +pub const CONV_RESTLEN = @as(c_int, 30); +pub const WRITEBUFSIZE = @as(c_int, 8192); +pub const ICONV_MULT = @as(c_int, 8); +pub const NVIM_GETCHAR_H = ""; +pub const NVIM_OS_FILEIO_H = ""; +pub const KEYLEN_PART_KEY = -@as(c_int, 1); +pub const KEYLEN_PART_MAP = -@as(c_int, 2); +pub const NVIM_GRID_H = ""; +pub const DEFAULT_GRID_HANDLE = @as(c_int, 1); +pub const NVIM_HELP_H = ""; +pub const NVIM_HIGHLIGHT_H = ""; +pub const HLATTRS_DICT_SIZE = @as(c_int, 16); +pub const NVIM_HIGHLIGHT_GROUP_H = ""; +pub const NVIM_API_PRIVATE_HELPERS_H = ""; +pub inline fn OBJECT_OBJ(o: anytype) @TypeOf(o) { + return o; +} +pub inline fn BOOL(b: anytype) @TypeOf(BOOLEAN_OBJ(b)) { + return BOOLEAN_OBJ(b); +} +pub inline fn CSTR_TO_OBJ(s: anytype) @TypeOf(STRING_OBJ(cstr_to_string(s))) { + return STRING_OBJ(cstr_to_string(s)); +} +pub const NIL = @import("std").zig.c_translation.cast(Object, OBJECT_INIT); +pub const NULL_STRING = @import("std").zig.c_translation.cast(String, STRING_INIT); +pub inline fn HAS_KEY(o: anytype) @TypeOf(o.type != kObjectTypeNil) { + return o.type != kObjectTypeNil; +} +pub inline fn PUT(dict: anytype, k: anytype, v: anytype) @TypeOf(kv_push(dict, @import("std").mem.zeroInit(KeyValuePair, .{ + .key = cstr_to_string(k), + .value = v, +}))) { + return kv_push(dict, @import("std").mem.zeroInit(KeyValuePair, .{ + .key = cstr_to_string(k), + .value = v, + })); +} +pub inline fn PUT_C(dict: anytype, k: anytype, v: anytype) @TypeOf(kv_push_c(dict, @import("std").mem.zeroInit(KeyValuePair, .{ + .key = cstr_as_string(k), + .value = v, +}))) { + return kv_push_c(dict, @import("std").mem.zeroInit(KeyValuePair, .{ + .key = cstr_as_string(k), + .value = v, + })); +} +pub inline fn ADD(array: anytype, item: anytype) @TypeOf(kv_push(array, item)) { + return kv_push(array, item); +} +pub inline fn ADD_C(array: anytype, item: anytype) @TypeOf(kv_push_c(array, item)) { + return kv_push_c(array, item); +} +pub inline fn cbuf_as_string(d: anytype, s: anytype) String { + return @import("std").mem.zeroInit(String, .{ + .data = d, + .size = s, + }); +} +pub inline fn STATIC_CSTR_AS_STRING(s: anytype) String { + return @import("std").mem.zeroInit(String, .{ + .data = s, + .size = @import("std").zig.c_translation.sizeof(s) - @as(c_int, 1), + }); +} +pub inline fn STATIC_CSTR_TO_STRING(s: anytype) String { + return @import("std").mem.zeroInit(String, .{ + .data = xmemdupz(s, @import("std").zig.c_translation.sizeof(s) - @as(c_int, 1)), + .size = @import("std").zig.c_translation.sizeof(s) - @as(c_int, 1), + }); +} +pub const api_init_boolean = ""; +pub const api_init_integer = ""; +pub const api_init_float = ""; +pub const api_init_buffer = ""; +pub const api_init_window = ""; +pub const api_init_tabpage = ""; +pub inline fn handle_get_buffer(h: anytype) @TypeOf(pmap_get(handle_T)(&buffer_handles, h)) { + return pmap_get(handle_T)(&buffer_handles, h); +} +pub inline fn handle_get_window(h: anytype) @TypeOf(pmap_get(handle_T)(&window_handles, h)) { + return pmap_get(handle_T)(&window_handles, h); +} +pub inline fn handle_get_tabpage(h: anytype) @TypeOf(pmap_get(handle_T)(&tabpage_handles, h)) { + return pmap_get(handle_T)(&tabpage_handles, h); +} +pub const MAX_HL_ID = @as(c_int, 20000); +pub const NVIM_INDENT_H = ""; +pub const SIN_CHANGED = @as(c_int, 1); +pub const SIN_INSERT = @as(c_int, 2); +pub const SIN_UNDO = @as(c_int, 4); +pub const SIN_NOMARK = @as(c_int, 8); +pub const NVIM_INDENT_C_H = ""; +pub const NVIM_INPUT_H = ""; +pub const NVIM_INSEXPAND_H = ""; +pub const NVIM_LIB_RINGBUF_H = ""; +pub inline fn _RINGBUF_LENGTH(rb: anytype) @TypeOf(if (rb.*.first == NULL) @as(c_int, 0) else if (rb.*.next == rb.*.first) @import("std").zig.c_translation.cast(usize, rb.*.buf_end - rb.*.buf) + @as(c_int, 1) else if (rb.*.next > rb.*.first) @import("std").zig.c_translation.cast(usize, rb.*.next - rb.*.first) else @import("std").zig.c_translation.cast(usize, (((rb.*.next - rb.*.buf) + rb.*.buf_end) - rb.*.first) + @as(c_int, 1))) { + return if (rb.*.first == NULL) @as(c_int, 0) else if (rb.*.next == rb.*.first) @import("std").zig.c_translation.cast(usize, rb.*.buf_end - rb.*.buf) + @as(c_int, 1) else if (rb.*.next > rb.*.first) @import("std").zig.c_translation.cast(usize, rb.*.next - rb.*.first) else @import("std").zig.c_translation.cast(usize, (((rb.*.next - rb.*.buf) + rb.*.buf_end) - rb.*.first) + @as(c_int, 1)); +} +pub inline fn _RINGBUF_NEXT(rb: anytype, @"var": anytype) @TypeOf(if (@"var" == rb.*.buf_end) rb.*.buf else @"var" + @as(c_int, 1)) { + return if (@"var" == rb.*.buf_end) rb.*.buf else @"var" + @as(c_int, 1); +} +pub inline fn _RINGBUF_PREV(rb: anytype, @"var": anytype) @TypeOf(if (@"var" == rb.*.buf) rb.*.buf_end else @"var" - @as(c_int, 1)) { + return if (@"var" == rb.*.buf) rb.*.buf_end else @"var" - @as(c_int, 1); +} +pub const NVIM_LINEMATCH_H = ""; +pub const NVIM_LUA_CONVERTER_H = ""; +pub const NVIM_LUA_EXECUTOR_H = ""; +pub const NVIM_USERCMD_H = ""; +pub const UC_BUFFER = @as(c_int, 1); +pub inline fn USER_CMD(i: anytype) @TypeOf(&@import("std").zig.c_translation.cast([*c]ucmd_T, ucmds.ga_data)[@intCast(usize, i)]) { + return &@import("std").zig.c_translation.cast([*c]ucmd_T, ucmds.ga_data)[@intCast(usize, i)]; +} +pub inline fn USER_CMD_GA(gap: anytype, i: anytype) @TypeOf(&@import("std").zig.c_translation.cast([*c]ucmd_T, gap.*.ga_data)[@intCast(usize, i)]) { + return &@import("std").zig.c_translation.cast([*c]ucmd_T, gap.*.ga_data)[@intCast(usize, i)]; +} +pub inline fn NLUA_EXEC_STATIC(cstr: anytype, arg: anytype, err: anytype) @TypeOf(nlua_exec(STATIC_CSTR_AS_STRING(cstr), arg, err)) { + return nlua_exec(STATIC_CSTR_AS_STRING(cstr), arg, err); +} +pub const NVIM_LUA_SPELL_H = ""; +pub const lualib_h = ""; +pub const LUA_VERSUFFIX = "_" ++ LUA_VERSION_MAJOR ++ "_" ++ LUA_VERSION_MINOR; +pub const LUA_COLIBNAME = "coroutine"; +pub const LUA_TABLIBNAME = "table"; +pub const LUA_IOLIBNAME = "io"; +pub const LUA_OSLIBNAME = "os"; +pub const LUA_STRLIBNAME = "string"; +pub const LUA_UTF8LIBNAME = "utf8"; +pub const LUA_MATHLIBNAME = "math"; +pub const LUA_DBLIBNAME = "debug"; +pub const LUA_LOADLIBNAME = "package"; +pub const NVIM_LUA_STDLIB_H = ""; +pub const NVIM_LUA_TREESITTER_H = ""; +pub const TREE_SITTER_API_H_ = ""; +pub const TREE_SITTER_LANGUAGE_VERSION = @as(c_int, 14); +pub const TREE_SITTER_MIN_COMPATIBLE_LANGUAGE_VERSION = @as(c_int, 13); +pub const NVIM_LUA_XDIFF_H = ""; +pub const NVIM_MAPPING_H = ""; +pub const MAPTYPE_MAP = @as(c_int, 0); +pub const MAPTYPE_UNMAP = @as(c_int, 1); +pub const MAPTYPE_NOREMAP = @as(c_int, 2); +pub const NVIM_MARK_H = ""; +pub inline fn CLEAR_FMARK(fmarkp_: anytype) @TypeOf(RESET_FMARK(fmarkp_, @import("std").mem.zeroInit(pos_T, .{ @as(c_int, 0), @as(c_int, 0), @as(c_int, 0) }), @as(c_int, 0), @import("std").zig.c_translation.cast(fmarkv_T, INIT_FMARKV))) { + return RESET_FMARK(fmarkp_, @import("std").mem.zeroInit(pos_T, .{ @as(c_int, 0), @as(c_int, 0), @as(c_int, 0) }), @as(c_int, 0), @import("std").zig.c_translation.cast(fmarkv_T, INIT_FMARKV)); +} +pub const NVIM_MATCH_H = ""; +pub const NVIM_MATH_H = ""; +pub const NVIM_MEMFILE_H = ""; +pub const MFS_ALL = @as(c_int, 1); +pub const MFS_STOP = @as(c_int, 2); +pub const MFS_FLUSH = @as(c_int, 4); +pub const MFS_ZERO = @as(c_int, 8); +pub const NVIM_MENU_H = ""; +pub const NVIM_MOUSE_H = ""; +pub const NVIM_WINDOW_H = ""; +pub const FNAME_MESS = @as(c_int, 1); +pub const FNAME_EXP = @as(c_int, 2); +pub const FNAME_HYP = @as(c_int, 4); +pub const FNAME_INCL = @as(c_int, 8); +pub const FNAME_REL = @as(c_int, 16); +pub const FNAME_UNESC = @as(c_int, 32); +pub const WSP_ROOM = @as(c_int, 0x01); +pub const WSP_VERT = @as(c_int, 0x02); +pub const WSP_HOR = @as(c_int, 0x04); +pub const WSP_TOP = @as(c_int, 0x08); +pub const WSP_BOT = @as(c_int, 0x10); +pub const WSP_HELP = @as(c_int, 0x20); +pub const WSP_BELOW = @as(c_int, 0x40); +pub const WSP_ABOVE = @as(c_int, 0x80); +pub const WSP_NEWLOC = @as(c_int, 0x100); +pub const MIN_COLUMNS = @as(c_int, 12); +pub const MIN_LINES = @as(c_int, 2); +pub const NVIM_MOVE_H = ""; +pub const NVIM_MSGPACK_RPC_CHANNEL_H = ""; +pub const METHOD_MAXLEN = @as(c_int, 512); +pub const NVIM_MSGPACK_RPC_HELPERS_H = ""; +pub const EXT_OBJECT_TYPE_SHIFT = kObjectTypeBuffer; +pub const EXT_OBJECT_TYPE_MAX = kObjectTypeTabpage - EXT_OBJECT_TYPE_SHIFT; +pub const NVIM_MSGPACK_RPC_SERVER_H = ""; +pub const NVIM_MSGPACK_RPC_UNPACKER_H = ""; +pub const MPACK_CORE_H = ""; +pub const MPACK_MAX_TOKEN_LEN = @as(c_int, 9); +pub const MPACK_OBJECT_H = ""; +pub const MPACK_CONV_H = ""; +pub const mpack_pack_float = mpack_pack_float_fast; +pub const mpack_unpack_float = mpack_unpack_float_fast; +pub const MPACK_MAX_OBJECT_DEPTH = @as(c_int, 32); +pub inline fn MPACK_PARENT_NODE(n: anytype) @TypeOf(if ((n - @as(c_int, 1)).*.pos == @import("std").zig.c_translation.cast(usize, -@as(c_int, 1))) NULL else n - @as(c_int, 1)) { + return if ((n - @as(c_int, 1)).*.pos == @import("std").zig.c_translation.cast(usize, -@as(c_int, 1))) NULL else n - @as(c_int, 1); +} +pub inline fn MPACK_PARSER_STRUCT_SIZE(c: anytype) @TypeOf((@import("std").zig.c_translation.sizeof(mpack_node_t) * c) + @import("std").zig.c_translation.sizeof(mpack_one_parser_t)) { + return (@import("std").zig.c_translation.sizeof(mpack_node_t) * c) + @import("std").zig.c_translation.sizeof(mpack_one_parser_t); +} +pub const MAX_EXT_LEN = @as(c_int, 9); +pub inline fn unpacker_closed(p: anytype) @TypeOf(p.*.state < @as(c_int, 0)) { + return p.*.state < @as(c_int, 0); +} +pub const NVIM_OPS_H = ""; +pub const PUT_FIXINDENT = @as(c_int, 1); +pub const PUT_CURSEND = @as(c_int, 2); +pub const PUT_CURSLINE = @as(c_int, 4); +pub const PUT_LINE = @as(c_int, 8); +pub const PUT_LINE_SPLIT = @as(c_int, 16); +pub const PUT_LINE_FORWARD = @as(c_int, 32); +pub const PUT_BLOCK_INNER = @as(c_int, 64); +pub const DELETION_REGISTER = @as(c_int, 36); +pub const NUM_SAVED_REGISTERS = @as(c_int, 37); +pub const STAR_REGISTER = @as(c_int, 37); +pub const PLUS_REGISTER = @as(c_int, 38); +pub const NUM_REGISTERS = @as(c_int, 39); +pub const OP_NOP = @as(c_int, 0); +pub const OP_DELETE = @as(c_int, 1); +pub const OP_YANK = @as(c_int, 2); +pub const OP_CHANGE = @as(c_int, 3); +pub const OP_LSHIFT = @as(c_int, 4); +pub const OP_RSHIFT = @as(c_int, 5); +pub const OP_FILTER = @as(c_int, 6); +pub const OP_TILDE = @as(c_int, 7); +pub const OP_INDENT = @as(c_int, 8); +pub const OP_FORMAT = @as(c_int, 9); +pub const OP_COLON = @as(c_int, 10); +pub const OP_UPPER = @as(c_int, 11); +pub const OP_LOWER = @as(c_int, 12); +pub const OP_JOIN = @as(c_int, 13); +pub const OP_JOIN_NS = @as(c_int, 14); +pub const OP_ROT13 = @as(c_int, 15); +pub const OP_REPLACE = @as(c_int, 16); +pub const OP_INSERT = @as(c_int, 17); +pub const OP_APPEND = @as(c_int, 18); +pub const OP_FOLD = @as(c_int, 19); +pub const OP_FOLDOPEN = @as(c_int, 20); +pub const OP_FOLDOPENREC = @as(c_int, 21); +pub const OP_FOLDCLOSE = @as(c_int, 22); +pub const OP_FOLDCLOSEREC = @as(c_int, 23); +pub const OP_FOLDDEL = @as(c_int, 24); +pub const OP_FOLDDELREC = @as(c_int, 25); +pub const OP_FORMAT2 = @as(c_int, 26); +pub const OP_FUNCTION = @as(c_int, 27); +pub const OP_NR_ADD = @as(c_int, 28); +pub const OP_NR_SUB = @as(c_int, 29); +pub const NVIM_OPTION_H = ""; +pub const BCO_ENTER = @as(c_int, 1); +pub const BCO_ALWAYS = @as(c_int, 2); +pub const BCO_NOHELP = @as(c_int, 4); +pub const MAX_NUMBERWIDTH = @as(c_int, 20); +pub const NVIM_OPTIONSTR_H = ""; +pub const NVIM_PLINES_H = ""; +pub const NVIM_POPUPMENU_H = ""; +pub const NVIM_PROFILE_H = ""; +pub const NVIM_QUICKFIX_H = ""; +pub const VGR_GLOBAL = @as(c_int, 1); +pub const VGR_NOJUMP = @as(c_int, 2); +pub const VGR_FUZZY = @as(c_int, 4); +pub const NVIM_REGEXP_H = ""; +pub const RE_MAGIC = @as(c_int, 1); +pub const RE_STRING = @as(c_int, 2); +pub const RE_STRICT = @as(c_int, 4); +pub const RE_AUTO = @as(c_int, 8); +pub const RE_NOBREAK = @as(c_int, 16); +pub const REX_SET = @as(c_int, 1); +pub const REX_USE = @as(c_int, 2); +pub const REX_ALL = REX_SET | REX_USE; +pub const NVIM_SEARCH_H = ""; +pub const FIND_ANY = @as(c_int, 1); +pub const FIND_DEFINE = @as(c_int, 2); +pub const CHECK_PATH = @as(c_int, 3); +pub const ACTION_SHOW = @as(c_int, 1); +pub const ACTION_GOTO = @as(c_int, 2); +pub const ACTION_SPLIT = @as(c_int, 3); +pub const ACTION_SHOW_ALL = @as(c_int, 4); +pub const ACTION_EXPAND = @as(c_int, 5); +pub const SEARCH_REV = @as(c_int, 0x01); +pub const SEARCH_ECHO = @as(c_int, 0x02); +pub const SEARCH_MSG = @as(c_int, 0x0c); +pub const SEARCH_NFMSG = @as(c_int, 0x08); +pub const SEARCH_OPT = @as(c_int, 0x10); +pub const SEARCH_HIS = @as(c_int, 0x20); +pub const SEARCH_END = @as(c_int, 0x40); +pub const SEARCH_NOOF = @as(c_int, 0x80); +pub const SEARCH_START = @as(c_int, 0x100); +pub const SEARCH_MARK = @as(c_int, 0x200); +pub const SEARCH_KEEP = @as(c_int, 0x400); +pub const SEARCH_PEEK = @as(c_int, 0x800); +pub const SEARCH_COL = @as(c_int, 0x1000); +pub const FM_BACKWARD = @as(c_int, 0x01); +pub const FM_FORWARD = @as(c_int, 0x02); +pub const FM_BLOCKSTOP = @as(c_int, 0x04); +pub const FM_SKIPCOMM = @as(c_int, 0x08); +pub const RE_SEARCH = @as(c_int, 0); +pub const RE_SUBST = @as(c_int, 1); +pub const RE_BOTH = @as(c_int, 2); +pub const RE_LAST = @as(c_int, 2); +pub const SEARCH_STAT_DEF_TIMEOUT = @as(c_long, 40); +pub const SEARCH_STAT_DEF_MAX_COUNT = @as(c_int, 99); +pub const SEARCH_STAT_BUF_LEN = @as(c_int, 12); +pub const MAX_FUZZY_MATCHES = @as(c_int, 256); +pub const NVIM_SHA256_H = ""; +pub const SHA256_BUFFER_SIZE = @as(c_int, 64); +pub const SHA256_SUM_SIZE = @as(c_int, 32); +pub const NVIM_SHADA_H = ""; +pub const NVIM_SIGN_H = ""; +pub const NVIM_SPELL_H = ""; +pub const NVIM_SPELL_DEFS_H = ""; +pub const MAXWLEN = @as(c_int, 254); +pub const MAXREGIONS = @as(c_int, 8); +pub const SPL_FNAME_TMPL = "%s.%s.spl"; +pub const SPL_FNAME_ADD = ".add."; +pub const SPL_FNAME_ASCII = ".ascii."; +pub const WF_REGION = @as(c_int, 0x01); +pub const WF_ONECAP = @as(c_int, 0x02); +pub const WF_ALLCAP = @as(c_int, 0x04); +pub const WF_RARE = @as(c_int, 0x08); +pub const WF_BANNED = @as(c_int, 0x10); +pub const WF_AFX = @as(c_int, 0x20); +pub const WF_FIXCAP = @as(c_int, 0x40); +pub const WF_KEEPCAP = @as(c_int, 0x80); +pub const WF_CAPMASK = ((WF_ONECAP | WF_ALLCAP) | WF_KEEPCAP) | WF_FIXCAP; +pub const WF_HAS_AFF = @as(c_int, 0x0100); +pub const WF_NEEDCOMP = @as(c_int, 0x0200); +pub const WF_NOSUGGEST = @as(c_int, 0x0400); +pub const WF_COMPROOT = @as(c_int, 0x0800); +pub const WF_NOCOMPBEF = @as(c_int, 0x1000); +pub const WF_NOCOMPAFT = @as(c_int, 0x2000); +pub const WFP_RARE = @as(c_int, 0x01); +pub const WFP_NC = @as(c_int, 0x02); +pub const WFP_UP = @as(c_int, 0x04); +pub const WFP_COMPPERMIT = @as(c_int, 0x08); +pub const WFP_COMPFORBID = @as(c_int, 0x10); +pub const WF_RAREPFX = WFP_RARE << @as(c_int, 24); +pub const WF_PFX_NC = WFP_NC << @as(c_int, 24); +pub const WF_PFX_UP = WFP_UP << @as(c_int, 24); +pub const WF_PFX_COMPPERMIT = WFP_COMPPERMIT << @as(c_int, 24); +pub const WF_PFX_COMPFORBID = WFP_COMPFORBID << @as(c_int, 24); +pub const COMP_CHECKDUP = @as(c_int, 1); +pub const COMP_CHECKREP = @as(c_int, 2); +pub const COMP_CHECKCASE = @as(c_int, 4); +pub const COMP_CHECKTRIPLE = @as(c_int, 8); +pub const SP_TRUNCERROR = -@as(c_int, 1); +pub const SP_FORMERROR = -@as(c_int, 2); +pub const SP_OTHERERROR = -@as(c_int, 3); +pub inline fn LANGP_ENTRY(ga: anytype, i: anytype) @TypeOf(@import("std").zig.c_translation.cast([*c]langp_T, ga.ga_data) + i) { + return @import("std").zig.c_translation.cast([*c]langp_T, ga.ga_data) + i; +} +pub const VIMSUGMAGIC = "VIMsug"; +pub const VIMSUGMAGICL = @as(c_int, 6); +pub const VIMSUGVERSION = @as(c_int, 1); +pub const REGION_ALL = @as(c_int, 0xff); +pub inline fn SPELL_TOFOLD(c: anytype) @TypeOf(if (c >= @as(c_int, 128)) utf_fold(c) else @import("std").zig.c_translation.cast(c_int, spelltab.st_fold[@intCast(usize, c)])) { + return if (c >= @as(c_int, 128)) utf_fold(c) else @import("std").zig.c_translation.cast(c_int, spelltab.st_fold[@intCast(usize, c)]); +} +pub inline fn SPELL_TOUPPER(c: anytype) @TypeOf(if (c >= @as(c_int, 128)) mb_toupper(c) else @import("std").zig.c_translation.cast(c_int, spelltab.st_upper[@intCast(usize, c)])) { + return if (c >= @as(c_int, 128)) mb_toupper(c) else @import("std").zig.c_translation.cast(c_int, spelltab.st_upper[@intCast(usize, c)]); +} +pub inline fn SPELL_ISUPPER(c: anytype) @TypeOf(if (c >= @as(c_int, 128)) mb_isupper(c) else spelltab.st_isu[@intCast(usize, c)]) { + return if (c >= @as(c_int, 128)) mb_isupper(c) else spelltab.st_isu[@intCast(usize, c)]; +} +pub inline fn HI2WC(hi: anytype) [*c]wordcount_T { + return @import("std").zig.c_translation.cast([*c]wordcount_T, hi.*.hi_key - WC_KEY_OFF); +} +pub const MAXWORDCOUNT = @import("std").zig.c_translation.promoteIntLiteral(c_int, 0xffff, .hexadecimal); +pub const NVIM_SPELLFILE_H = ""; +pub const NVIM_SPELLSUGGEST_H = ""; +pub const NVIM_STATE_H = ""; +pub const NVIM_STATUSLINE_H = ""; +pub const NVIM_SYNTAX_H = ""; +pub const HL_CONTAINED = @as(c_int, 0x01); +pub const HL_TRANSP = @as(c_int, 0x02); +pub const HL_ONELINE = @as(c_int, 0x04); +pub const HL_HAS_EOL = @as(c_int, 0x08); +pub const HL_SYNC_HERE = @as(c_int, 0x10); +pub const HL_SYNC_THERE = @as(c_int, 0x20); +pub const HL_MATCH = @as(c_int, 0x40); +pub const HL_SKIPNL = @as(c_int, 0x80); +pub const HL_SKIPWHITE = @as(c_int, 0x100); +pub const HL_SKIPEMPTY = @as(c_int, 0x200); +pub const HL_KEEPEND = @as(c_int, 0x400); +pub const HL_EXCLUDENL = @as(c_int, 0x800); +pub const HL_DISPLAY = @as(c_int, 0x1000); +pub const HL_FOLD = @as(c_int, 0x2000); +pub const HL_EXTEND = @as(c_int, 0x4000); +pub const HL_MATCHCONT = @import("std").zig.c_translation.promoteIntLiteral(c_int, 0x8000, .hexadecimal); +pub const HL_TRANS_CONT = @import("std").zig.c_translation.promoteIntLiteral(c_int, 0x10000, .hexadecimal); +pub const HL_CONCEAL = @import("std").zig.c_translation.promoteIntLiteral(c_int, 0x20000, .hexadecimal); +pub const HL_CONCEALENDS = @import("std").zig.c_translation.promoteIntLiteral(c_int, 0x40000, .hexadecimal); +pub inline fn SYN_GROUP_STATIC(s: anytype) @TypeOf(syn_check_group(S_LEN(s))) { + return syn_check_group(S_LEN(s)); +} +pub const NVIM_TAG_H = ""; +pub const DT_TAG = @as(c_int, 1); +pub const DT_POP = @as(c_int, 2); +pub const DT_NEXT = @as(c_int, 3); +pub const DT_PREV = @as(c_int, 4); +pub const DT_FIRST = @as(c_int, 5); +pub const DT_LAST = @as(c_int, 6); +pub const DT_SELECT = @as(c_int, 7); +pub const DT_HELP = @as(c_int, 8); +pub const DT_JUMP = @as(c_int, 9); +pub const DT_LTAG = @as(c_int, 11); +pub const DT_FREE = @as(c_int, 99); +pub const TAG_HELP = @as(c_int, 1); +pub const TAG_NAMES = @as(c_int, 2); +pub const TAG_REGEXP = @as(c_int, 4); +pub const TAG_NOIC = @as(c_int, 8); +pub const TAG_VERBOSE = @as(c_int, 32); +pub const TAG_INS_COMP = @as(c_int, 64); +pub const TAG_KEEP_LANG = @as(c_int, 128); +pub const TAG_NO_TAGFUNC = @as(c_int, 256); +pub const TAG_MANY = @as(c_int, 300); +pub const NVIM_TESTING_H = ""; +pub const NVIM_TEXTFORMAT_H = ""; +pub const NVIM_TEXTOBJECT_H = ""; +pub const NVIM_TUI_INPUT_H = ""; +pub const GUARD_TERMKEY_H_ = ""; +pub const TERMKEY_VERSION_MAJOR = @as(c_int, 0); +pub const TERMKEY_VERSION_MINOR = @as(c_int, 22); +pub const TERMKEY_CHECK_VERSION = termkey_check_version(TERMKEY_VERSION_MAJOR, TERMKEY_VERSION_MINOR); +pub const TERMKEY_FORMAT_VIM = @import("std").zig.c_translation.cast(TermKeyFormat, TERMKEY_FORMAT_ALTISMETA | TERMKEY_FORMAT_WRAPBRACKET); +pub const TERMKEY_FORMAT_URWID = @import("std").zig.c_translation.cast(TermKeyFormat, (((TERMKEY_FORMAT_LONGMOD | TERMKEY_FORMAT_ALTISMETA) | TERMKEY_FORMAT_LOWERMOD) | TERMKEY_FORMAT_SPACEMOD) | TERMKEY_FORMAT_LOWERSPACE); +pub const NVIM_TUI_TUI_H = ""; +pub const NVIM_TUI_TERMINFO_H = ""; +pub const GUARD_UNIBILIUM_H_ = ""; +pub const NVIM_TUI_TERMINFO_DEFS_H = ""; +pub const NVIM_UGRID_H = ""; +pub const CELLBYTES = @import("std").zig.c_translation.sizeof(schar_T); +pub const NVIM_UI_COMPOSITOR_H = ""; +pub const NVIM_UNDO_H = ""; +pub const NVIM_VERSION_H = ""; +pub const VIM_VERSION_MAJOR = @as(c_int, 8); +pub const VIM_VERSION_MINOR = @as(c_int, 1); +pub const VIM_VERSION_MAJOR_STR = STR(VIM_VERSION_MAJOR); +pub const VIM_VERSION_MINOR_STR = STR(VIM_VERSION_MINOR); +pub const VIM_VERSION_100 = (VIM_VERSION_MAJOR * @as(c_int, 100)) + VIM_VERSION_MINOR; +pub const VIM_VERSION_NODOT = "vim" ++ VIM_VERSION_MAJOR_STR ++ VIM_VERSION_MINOR_STR; +pub const VIM_VERSION_SHORT = VIM_VERSION_MAJOR_STR ++ "." ++ VIM_VERSION_MINOR_STR; +pub const NVIM_VIML_PARSER_EXPRESSIONS_H = ""; +pub const NVIM_VIML_PARSER_PARSER_H = ""; +pub const __locale_data = struct___locale_data; +pub const __locale_struct = struct___locale_struct; +pub const timeval = struct_timeval; +pub const timespec = struct_timespec; +pub const __pthread_internal_list = struct___pthread_internal_list; +pub const __pthread_internal_slist = struct___pthread_internal_slist; +pub const __pthread_mutex_s = struct___pthread_mutex_s; +pub const __pthread_rwlock_arch_t = struct___pthread_rwlock_arch_t; +pub const __pthread_cond_s = struct___pthread_cond_s; +pub const random_data = struct_random_data; +pub const drand48_data = struct_drand48_data; +pub const tm = struct_tm; +pub const itimerspec = struct_itimerspec; +pub const sigval = union_sigval; +pub const sigevent = struct_sigevent; +pub const consumed_blk = struct_consumed_blk; +pub const __va_list_tag = struct___va_list_tag; +pub const _G_fpos_t = struct__G_fpos_t; +pub const _G_fpos64_t = struct__G_fpos64_t; +pub const _IO_marker = struct__IO_marker; +pub const _IO_codecvt = struct__IO_codecvt; +pub const _IO_wide_data = struct__IO_wide_data; +pub const _IO_FILE = struct__IO_FILE; +pub const _fpx_sw_bytes = struct__fpx_sw_bytes; +pub const _fpreg = struct__fpreg; +pub const _fpxreg = struct__fpxreg; +pub const _xmmreg = struct__xmmreg; +pub const _fpstate = struct__fpstate; +pub const sigcontext = struct_sigcontext; +pub const _xsave_hdr = struct__xsave_hdr; +pub const _ymmh_state = struct__ymmh_state; +pub const _xstate = struct__xstate; +pub const _libc_fpxreg = struct__libc_fpxreg; +pub const _libc_xmmreg = struct__libc_xmmreg; +pub const _libc_fpstate = struct__libc_fpstate; +pub const termios = struct_termios; +pub const object = struct_object; +pub const expand = struct_expand; +pub const key_value_pair = struct_key_value_pair; +pub const CallInfo = struct_CallInfo; +pub const mf_hashitem = struct_mf_hashitem; +pub const bhdr = struct_bhdr; +pub const mf_hashtab = struct_mf_hashtab; +pub const memfile = struct_memfile; +pub const info_pointer = struct_info_pointer; +pub const ml_chunksize = struct_ml_chunksize; +pub const memline = struct_memline; +pub const frame_S = struct_frame_S; +pub const w_line = struct_w_line; +pub const growarray = struct_growarray; +pub const arglist = struct_arglist; +pub const hashitem_S = struct_hashitem_S; +pub const hashtable_S = struct_hashtable_S; +pub const _queue = struct__queue; +pub const dictvar_S = struct_dictvar_S; +pub const fmarkv = struct_fmarkv; +pub const filemark = struct_filemark; +pub const xfilemark = struct_xfilemark; +pub const matchitem = struct_matchitem; +pub const taggy = struct_taggy; +pub const qf_info_S = struct_qf_info_S; +pub const window_S = struct_window_S; +pub const wininfo_S = struct_wininfo_S; +pub const mapblock = struct_mapblock; +pub const u_entry = struct_u_entry; +pub const u_header = struct_u_header; +pub const signgroup_S = struct_signgroup_S; +pub const sign_entry = struct_sign_entry; +pub const terminal = struct_terminal; +pub const file_buffer = struct_file_buffer; +pub const ListLenSpecials = enum_ListLenSpecials; +pub const listitem_S = struct_listitem_S; +pub const listwatch_S = struct_listwatch_S; +pub const listvar_S = struct_listvar_S; +pub const funccall_S = struct_funccall_S; +pub const ufunc = struct_ufunc; +pub const partial_S = struct_partial_S; +pub const blobvar_S = struct_blobvar_S; +pub const dict_watcher = struct_dict_watcher; +pub const typval_vval_union = union_typval_vval_union; +pub const ht_stack_S = struct_ht_stack_S; +pub const list_stack_S = struct_list_stack_S; +pub const msg_hist = struct_msg_hist; +pub const attr_entry = struct_attr_entry; +pub const undo_object = struct_undo_object; +pub const mtnode_s = struct_mtnode_s; +pub const vimoption = struct_vimoption; +pub const foldinfo = struct_foldinfo; +pub const stl_hlrec = struct_stl_hlrec; +pub const stl_item = struct_stl_item; +pub const statuscol = struct_statuscol; +pub const mf_blocknr_trans_item = struct_mf_blocknr_trans_item; +pub const flock = struct_flock; +pub const dirent = struct_dirent; +pub const __dirstream = struct___dirstream; +pub const iovec = struct_iovec; +pub const __socket_type = enum___socket_type; +pub const sockaddr = struct_sockaddr; +pub const sockaddr_storage = struct_sockaddr_storage; +pub const msghdr = struct_msghdr; +pub const cmsghdr = struct_cmsghdr; +pub const linger = struct_linger; +pub const osockaddr = struct_osockaddr; +pub const in_addr = struct_in_addr; +pub const ip_opts = struct_ip_opts; +pub const in_pktinfo = struct_in_pktinfo; +pub const in6_addr = struct_in6_addr; +pub const sockaddr_in = struct_sockaddr_in; +pub const sockaddr_in6 = struct_sockaddr_in6; +pub const ip_mreq = struct_ip_mreq; +pub const ip_mreqn = struct_ip_mreqn; +pub const ip_mreq_source = struct_ip_mreq_source; +pub const ipv6_mreq = struct_ipv6_mreq; +pub const group_req = struct_group_req; +pub const group_source_req = struct_group_source_req; +pub const ip_msfilter = struct_ip_msfilter; +pub const group_filter = struct_group_filter; +pub const tcphdr = struct_tcphdr; +pub const tcp_ca_state = enum_tcp_ca_state; +pub const tcp_info = struct_tcp_info; +pub const tcp_md5sig = struct_tcp_md5sig; +pub const tcp_repair_opt = struct_tcp_repair_opt; +pub const tcp_cookie_transactions = struct_tcp_cookie_transactions; +pub const tcp_repair_window = struct_tcp_repair_window; +pub const tcp_zerocopy_receive = struct_tcp_zerocopy_receive; +pub const rpcent = struct_rpcent; +pub const netent = struct_netent; +pub const hostent = struct_hostent; +pub const servent = struct_servent; +pub const protoent = struct_protoent; +pub const addrinfo = struct_addrinfo; +pub const passwd = struct_passwd; +pub const sched_param = struct_sched_param; +pub const __jmp_buf_tag = struct___jmp_buf_tag; +pub const _pthread_cleanup_buffer = struct__pthread_cleanup_buffer; +pub const __cancel_jmp_buf_tag = struct___cancel_jmp_buf_tag; +pub const __pthread_cleanup_frame = struct___pthread_cleanup_frame; +pub const uv__io_s = struct_uv__io_s; +pub const uv_handle_s = struct_uv_handle_s; +pub const uv_async_s = struct_uv_async_s; +pub const uv_signal_s = struct_uv_signal_s; +pub const uv_loop_s = struct_uv_loop_s; +pub const uv__work = struct_uv__work; +pub const uv_dirent_s = struct_uv_dirent_s; +pub const uv_dir_s = struct_uv_dir_s; +pub const uv_connect_s = struct_uv_connect_s; +pub const uv_shutdown_s = struct_uv_shutdown_s; +pub const uv_stream_s = struct_uv_stream_s; +pub const uv_tcp_s = struct_uv_tcp_s; +pub const uv_udp_s = struct_uv_udp_s; +pub const uv_pipe_s = struct_uv_pipe_s; +pub const uv_tty_s = struct_uv_tty_s; +pub const uv_poll_s = struct_uv_poll_s; +pub const uv_timer_s = struct_uv_timer_s; +pub const uv_prepare_s = struct_uv_prepare_s; +pub const uv_check_s = struct_uv_check_s; +pub const uv_idle_s = struct_uv_idle_s; +pub const uv_process_s = struct_uv_process_s; +pub const uv_fs_event_s = struct_uv_fs_event_s; +pub const uv_fs_poll_s = struct_uv_fs_poll_s; +pub const uv_req_s = struct_uv_req_s; +pub const uv_getaddrinfo_s = struct_uv_getaddrinfo_s; +pub const uv_getnameinfo_s = struct_uv_getnameinfo_s; +pub const uv_write_s = struct_uv_write_s; +pub const uv_udp_send_s = struct_uv_udp_send_s; +pub const uv_fs_s = struct_uv_fs_s; +pub const uv_work_s = struct_uv_work_s; +pub const uv_random_s = struct_uv_random_s; +pub const uv_env_item_s = struct_uv_env_item_s; +pub const uv_cpu_times_s = struct_uv_cpu_times_s; +pub const uv_cpu_info_s = struct_uv_cpu_info_s; +pub const uv_interface_address_s = struct_uv_interface_address_s; +pub const uv_passwd_s = struct_uv_passwd_s; +pub const uv_utsname_s = struct_uv_utsname_s; +pub const uv_statfs_s = struct_uv_statfs_s; +pub const uv_tcp_flags = enum_uv_tcp_flags; +pub const uv_udp_flags = enum_uv_udp_flags; +pub const uv_poll_event = enum_uv_poll_event; +pub const uv_stdio_container_s = struct_uv_stdio_container_s; +pub const uv_process_options_s = struct_uv_process_options_s; +pub const uv_process_flags = enum_uv_process_flags; +pub const uv_fs_event = enum_uv_fs_event; +pub const uv_fs_event_flags = enum_uv_fs_event_flags; +pub const uv_thread_options_s = struct_uv_thread_options_s; +pub const uv_any_handle = union_uv_any_handle; +pub const uv_any_req = union_uv_any_req; +pub const regprog = struct_regprog; +pub const regengine = struct_regengine; +pub const reg_extmatch = struct_reg_extmatch; +pub const nfa_state = struct_nfa_state; +pub const buf_state = struct_buf_state; +pub const syn_state = struct_syn_state; +pub const sp_syn = struct_sp_syn; +pub const keyentry = struct_keyentry; +pub const buffblock = struct_buffblock; +pub const buffheader = struct_buffheader; +pub const argentry = struct_argentry; +pub const diffblock_S = struct_diffblock_S; +pub const tabpage_S = struct_tabpage_S; +pub const virt_line = struct_virt_line; +pub const oparg_S = struct_oparg_S; +pub const cmdarg_S = struct_cmdarg_S; +pub const CMD_index = enum_CMD_index; +pub const exarg = struct_exarg; +pub const aucmd_executable_t = struct_aucmd_executable_t; +pub const cmdname = struct_cmdname; +pub const eslist_elem = struct_eslist_elem; +pub const message = struct_message; +pub const multiqueue = struct_multiqueue; +pub const __kl1_WatcherPtr = struct___kl1_WatcherPtr; +pub const loop = struct_loop; +pub const msglist = struct_msglist; +pub const vim_exception = struct_vim_exception; +pub const cleanup_stuff = struct_cleanup_stuff; +pub const VimMenu = struct_VimMenu; +pub const AutoCmd_S = struct_AutoCmd_S; +pub const AutoPat_S = struct_AutoPat_S; +pub const auto_event = enum_auto_event; +pub const AutoPatCmd_S = struct_AutoPatCmd_S; +pub const nvim_stats_s = struct_nvim_stats_s; +pub const caller_scope = struct_caller_scope; +pub const ui_t = struct_ui_t; +pub const ui_event_callback = struct_ui_event_callback; +pub const getf_values = enum_getf_values; +pub const getf_retvalues = enum_getf_retvalues; +pub const bln_values = enum_bln_values; +pub const dobuf_action_values = enum_dobuf_action_values; +pub const dobuf_start_values = enum_dobuf_start_values; +pub const bfa_values = enum_bfa_values; +pub const rbuffer = struct_rbuffer; +pub const stream = struct_stream; +pub const wbuffer = struct_wbuffer; +pub const process = struct_process; +pub const libuv_process = struct_libuv_process; +pub const socket_watcher = struct_socket_watcher; +pub const key_extra = enum_key_extra; +pub const file_comparison = enum_file_comparison; +pub const winsize = struct_winsize; +pub const pty_process = struct_pty_process; +pub const mpack_value_s = struct_mpack_value_s; +pub const mpack_token_s = struct_mpack_token_s; +pub const mpack_tokbuf_s = struct_mpack_tokbuf_s; +pub const termio = struct_termio; +pub const cmdline_info = struct_cmdline_info; +pub const hist_entry = struct_hist_entry; +pub const cursor_entry = struct_cursor_entry; +pub const signal_watcher = struct_signal_watcher; +pub const time_watcher = struct_time_watcher; +pub const RemapValues = enum_RemapValues; +pub const ucmd = struct_ucmd; +pub const map_arguments = struct_map_arguments; +pub const mpack_node_s = struct_mpack_node_s; +pub const GRegFlags = enum_GRegFlags; +pub const yankreg = struct_yankreg; +pub const soffset = struct_soffset; +pub const spat = struct_spat; +pub const searchstat = struct_searchstat; +pub const fromto_S = struct_fromto_S; +pub const salitem_S = struct_salitem_S; +pub const slang_S = struct_slang_S; +pub const langp_S = struct_langp_S; +pub const wordcount_S = struct_wordcount_S; +pub const vim_state = struct_vim_state; +pub const term_input = struct_term_input; +pub const unibi_boolean = enum_unibi_boolean; +pub const unibi_numeric = enum_unibi_numeric; +pub const unibi_string = enum_unibi_string; +pub const ucell = struct_ucell; +pub const ugrid = struct_ugrid; +pub const expr_ast_node = struct_expr_ast_node; +pub const ExprParserFlags = enum_ExprParserFlags; diff --git a/src/main.zig b/src/main.zig new file mode 100644 index 0000000..c9d5a12 --- /dev/null +++ b/src/main.zig @@ -0,0 +1,27 @@ +const std = @import("std"); +const c = @import("nvim_c"); + +/// Convenient wrapper for nvim's Error +pub const Error = struct { + err: c.Error = .{ .type = c.kErrorTypeNone, .msg = null }, + + pub fn handle(self: Error) !void { + switch (self.err.type) { + c.kErrorTypeNone => {}, + c.kErrorTypeValidation => return error.NvimValidation, + c.kErrorTypeException => return error.NvimException, + } + } + + pub fn handleLog(self: Error) !void { + self.handle() catch |e| { + if (self.msg()) |m| + std.log.scoped(.nvim).err("{s}", .{m}); + return e; + }; + } + + pub fn msg(self: Error) ?[:0]u8 { + return self.err.msg; + } +};