File harec-1699297758.b4dd427.obscpio of Package harec

Overview Repositories Revisions Requests Users Attributes Meta

File harec-1699297758.b4dd427.obscpio of Package harec (Revision 79337310fe0f191a7ac880c9892f1058)

Currently displaying revision 79337310fe0f191a7ac880c9892f1058 , Show latest

07070100000000000041ED000000000000000000000002654939DE00000000000000000000000000000000000000000000002100000000harec-1699297758.b4dd427/.builds07070100000001000081A4000000000000000000000001654939DE000002DE000000000000000000000000000000000000002C00000000harec-1699297758.b4dd427/.builds/alpine.ymlimage: alpine/latest
sources:
- https://git.sr.ht/~sircmpwn/hare
- https://git.sr.ht/~sircmpwn/harec
- git://c9x.me/qbe.git
tasks:
- signoff: |
    cd harec
    if [ "$BUILD_REASON" = "patchset" ]
    then
        if ! git log --format='%b' origin/master^^.. | grep 'Signed-off-by' >/dev/null
        then
            echo "Patch missing Signed-off-by"
            exit 1
        fi
    fi
- qbe: |
    cd qbe
    make -j2 PREFIX=/usr
    sudo make install PREFIX=/usr
- prepare: |
    mkdir harec/build
    cd harec/build
    ../configure
- build: |
    cd harec/build
    make -j2
    sudo make install
- tests: |
    cd harec/build
    make check
- stdlib-tests: |
    cd hare
    cp config.example.mk config.mk
    make -j2 check
07070100000002000081A4000000000000000000000001654939DE00000160000000000000000000000000000000000000002D00000000harec-1699297758.b4dd427/.builds/freebsd.ymlimage: freebsd/latest
sources:
- https://git.sr.ht/~sircmpwn/harec
- git://c9x.me/qbe.git
packages:
- binutils
tasks:
- qbe: |
    cd qbe
    make PREFIX=/usr
    sudo make install PREFIX=/usr
- prepare: |
    mkdir harec/build
    cd harec/build
    ../configure
- build: |
    cd harec/build
    make -j2
- tests: |
    cd harec/build
    make check
07070100000003000081A4000000000000000000000001654939DE0000015C000000000000000000000000000000000000002C00000000harec-1699297758.b4dd427/.builds/netbsd.ymlimage: netbsd/9.x
sources:
- https://git.sr.ht/~sircmpwn/harec
- git://c9x.me/qbe.git
packages:
- binutils
tasks:
- qbe: |
    cd qbe
    make PREFIX=/usr
    sudo make install PREFIX=/usr
- prepare: |
    mkdir harec/build
    cd harec/build
    ../configure
- build: |
    cd harec/build
    make -j2
- tests: |
    cd harec/build
    make check
07070100000004000081A4000000000000000000000001654939DE0000005C000000000000000000000000000000000000002400000000harec-1699297758.b4dd427/.gitignorebuild
.build/
mod/
harec*
**/*.o
**/*.a
tests/*
!tests/*.ha
!tests/run
!Makefile
!configure
07070100000005000081A4000000000000000000000001654939DE0000001D000000000000000000000000000000000000002200000000harec-1699297758.b4dd427/.mailmapEmber Sawady <ecs@d2evs.net>
07070100000006000081A4000000000000000000000001654939DE0000894D000000000000000000000000000000000000002100000000harec-1699297758.b4dd427/COPYING                    GNU GENERAL PUBLIC LICENSE
                       Version 3, 29 June 2007

Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
 Everyone is permitted to copy and distribute verbatim copies
 of this license document, but changing it is not allowed.

Preamble

The GNU General Public License is a free, copyleft license for
software and other kinds of works.

The licenses for most software and other practical works are designed
to take away your freedom to share and change the works.  By contrast,
the GNU General Public License is intended to guarantee your freedom to
share and change all versions of a program--to make sure it remains free
software for all its users.  We, the Free Software Foundation, use the
GNU General Public License for most of our software; it applies also to
any other work released this way by its authors.  You can apply it to
your programs, too.

When we speak of free software, we are referring to freedom, not
price.  Our General Public Licenses are designed to make sure that you
have the freedom to distribute copies of free software (and charge for
them if you wish), that you receive source code or can get it if you
want it, that you can change the software or use pieces of it in new
free programs, and that you know you can do these things.

To protect your rights, we need to prevent others from denying you
these rights or asking you to surrender the rights.  Therefore, you have
certain responsibilities if you distribute copies of the software, or if
you modify it: responsibilities to respect the freedom of others.

For example, if you distribute copies of such a program, whether
gratis or for a fee, you must pass on to the recipients the same
freedoms that you received.  You must make sure that they, too, receive
or can get the source code.  And you must show them these terms so they
know their rights.

Developers that use the GNU GPL protect your rights with two steps:
(1) assert copyright on the software, and (2) offer you this License
giving you legal permission to copy, distribute and/or modify it.

For the developers' and authors' protection, the GPL clearly explains
that there is no warranty for this free software.  For both users' and
authors' sake, the GPL requires that modified versions be marked as
changed, so that their problems will not be attributed erroneously to
authors of previous versions.

Some devices are designed to deny users access to install or run
modified versions of the software inside them, although the manufacturer
can do so.  This is fundamentally incompatible with the aim of
protecting users' freedom to change the software.  The systematic
pattern of such abuse occurs in the area of products for individuals to
use, which is precisely where it is most unacceptable.  Therefore, we
have designed this version of the GPL to prohibit the practice for those
products.  If such problems arise substantially in other domains, we
stand ready to extend this provision to those domains in future versions
of the GPL, as needed to protect the freedom of users.

Finally, every program is threatened constantly by software patents.
States should not allow patents to restrict development and use of
software on general-purpose computers, but in those that do, we wish to
avoid the special danger that patents applied to a free program could
make it effectively proprietary.  To prevent this, the GPL assures that
patents cannot be used to render the program non-free.

The precise terms and conditions for copying, distribution and
modification follow.

TERMS AND CONDITIONS

0. Definitions.

"This License" refers to version 3 of the GNU General Public License.

"Copyright" also means copyright-like laws that apply to other kinds of
works, such as semiconductor masks.

"The Program" refers to any copyrightable work licensed under this
License.  Each licensee is addressed as "you".  "Licensees" and
"recipients" may be individuals or organizations.

To "modify" a work means to copy from or adapt all or part of the work
in a fashion requiring copyright permission, other than the making of an
exact copy.  The resulting work is called a "modified version" of the
earlier work or a work "based on" the earlier work.

A "covered work" means either the unmodified Program or a work based
on the Program.

To "propagate" a work means to do anything with it that, without
permission, would make you directly or secondarily liable for
infringement under applicable copyright law, except executing it on a
computer or modifying a private copy.  Propagation includes copying,
distribution (with or without modification), making available to the
public, and in some countries other activities as well.

To "convey" a work means any kind of propagation that enables other
parties to make or receive copies.  Mere interaction with a user through
a computer network, with no transfer of a copy, is not conveying.

An interactive user interface displays "Appropriate Legal Notices"
to the extent that it includes a convenient and prominently visible
feature that (1) displays an appropriate copyright notice, and (2)
tells the user that there is no warranty for the work (except to the
extent that warranties are provided), that licensees may convey the
work under this License, and how to view a copy of this License.  If
the interface presents a list of user commands or options, such as a
menu, a prominent item in the list meets this criterion.

1. Source Code.

The "source code" for a work means the preferred form of the work
for making modifications to it.  "Object code" means any non-source
form of a work.

A "Standard Interface" means an interface that either is an official
standard defined by a recognized standards body, or, in the case of
interfaces specified for a particular programming language, one that
is widely used among developers working in that language.

The "System Libraries" of an executable work include anything, other
than the work as a whole, that (a) is included in the normal form of
packaging a Major Component, but which is not part of that Major
Component, and (b) serves only to enable use of the work with that
Major Component, or to implement a Standard Interface for which an
implementation is available to the public in source code form.  A
"Major Component", in this context, means a major essential component
(kernel, window system, and so on) of the specific operating system
(if any) on which the executable work runs, or a compiler used to
produce the work, or an object code interpreter used to run it.

The "Corresponding Source" for a work in object code form means all
the source code needed to generate, install, and (for an executable
work) run the object code and to modify the work, including scripts to
control those activities.  However, it does not include the work's
System Libraries, or general-purpose tools or generally available free
programs which are used unmodified in performing those activities but
which are not part of the work.  For example, Corresponding Source
includes interface definition files associated with source files for
the work, and the source code for shared libraries and dynamically
linked subprograms that the work is specifically designed to require,
such as by intimate data communication or control flow between those
subprograms and other parts of the work.

The Corresponding Source need not include anything that users
can regenerate automatically from other parts of the Corresponding
Source.

The Corresponding Source for a work in source code form is that
same work.

2. Basic Permissions.

All rights granted under this License are granted for the term of
copyright on the Program, and are irrevocable provided the stated
conditions are met.  This License explicitly affirms your unlimited
permission to run the unmodified Program.  The output from running a
covered work is covered by this License only if the output, given its
content, constitutes a covered work.  This License acknowledges your
rights of fair use or other equivalent, as provided by copyright law.

You may make, run and propagate covered works that you do not
convey, without conditions so long as your license otherwise remains
in force.  You may convey covered works to others for the sole purpose
of having them make modifications exclusively for you, or provide you
with facilities for running those works, provided that you comply with
the terms of this License in conveying all material for which you do
not control copyright.  Those thus making or running the covered works
for you must do so exclusively on your behalf, under your direction
and control, on terms that prohibit them from making any copies of
your copyrighted material outside their relationship with you.

Conveying under any other circumstances is permitted solely under
the conditions stated below.  Sublicensing is not allowed; section 10
makes it unnecessary.

3. Protecting Users' Legal Rights From Anti-Circumvention Law.

No covered work shall be deemed part of an effective technological
measure under any applicable law fulfilling obligations under article
11 of the WIPO copyright treaty adopted on 20 December 1996, or
similar laws prohibiting or restricting circumvention of such
measures.

When you convey a covered work, you waive any legal power to forbid
circumvention of technological measures to the extent such circumvention
is effected by exercising rights under this License with respect to
the covered work, and you disclaim any intention to limit operation or
modification of the work as a means of enforcing, against the work's
users, your or third parties' legal rights to forbid circumvention of
technological measures.

4. Conveying Verbatim Copies.

You may convey verbatim copies of the Program's source code as you
receive it, in any medium, provided that you conspicuously and
appropriately publish on each copy an appropriate copyright notice;
keep intact all notices stating that this License and any
non-permissive terms added in accord with section 7 apply to the code;
keep intact all notices of the absence of any warranty; and give all
recipients a copy of this License along with the Program.

You may charge any price or no price for each copy that you convey,
and you may offer support or warranty protection for a fee.

5. Conveying Modified Source Versions.

You may convey a work based on the Program, or the modifications to
produce it from the Program, in the form of source code under the
terms of section 4, provided that you also meet all of these conditions:

a) The work must carry prominent notices stating that you modified
    it, and giving a relevant date.

b) The work must carry prominent notices stating that it is
    released under this License and any conditions added under section
    7.  This requirement modifies the requirement in section 4 to
    "keep intact all notices".

c) You must license the entire work, as a whole, under this
    License to anyone who comes into possession of a copy.  This
    License will therefore apply, along with any applicable section 7
    additional terms, to the whole of the work, and all its parts,
    regardless of how they are packaged.  This License gives no
    permission to license the work in any other way, but it does not
    invalidate such permission if you have separately received it.

d) If the work has interactive user interfaces, each must display
    Appropriate Legal Notices; however, if the Program has interactive
    interfaces that do not display Appropriate Legal Notices, your
    work need not make them do so.

A compilation of a covered work with other separate and independent
works, which are not by their nature extensions of the covered work,
and which are not combined with it such as to form a larger program,
in or on a volume of a storage or distribution medium, is called an
"aggregate" if the compilation and its resulting copyright are not
used to limit the access or legal rights of the compilation's users
beyond what the individual works permit.  Inclusion of a covered work
in an aggregate does not cause this License to apply to the other
parts of the aggregate.

6. Conveying Non-Source Forms.

You may convey a covered work in object code form under the terms
of sections 4 and 5, provided that you also convey the
machine-readable Corresponding Source under the terms of this License,
in one of these ways:

a) Convey the object code in, or embodied in, a physical product
    (including a physical distribution medium), accompanied by the
    Corresponding Source fixed on a durable physical medium
    customarily used for software interchange.

b) Convey the object code in, or embodied in, a physical product
    (including a physical distribution medium), accompanied by a
    written offer, valid for at least three years and valid for as
    long as you offer spare parts or customer support for that product
    model, to give anyone who possesses the object code either (1) a
    copy of the Corresponding Source for all the software in the
    product that is covered by this License, on a durable physical
    medium customarily used for software interchange, for a price no
    more than your reasonable cost of physically performing this
    conveying of source, or (2) access to copy the
    Corresponding Source from a network server at no charge.

c) Convey individual copies of the object code with a copy of the
    written offer to provide the Corresponding Source.  This
    alternative is allowed only occasionally and noncommercially, and
    only if you received the object code with such an offer, in accord
    with subsection 6b.

d) Convey the object code by offering access from a designated
    place (gratis or for a charge), and offer equivalent access to the
    Corresponding Source in the same way through the same place at no
    further charge.  You need not require recipients to copy the
    Corresponding Source along with the object code.  If the place to
    copy the object code is a network server, the Corresponding Source
    may be on a different server (operated by you or a third party)
    that supports equivalent copying facilities, provided you maintain
    clear directions next to the object code saying where to find the
    Corresponding Source.  Regardless of what server hosts the
    Corresponding Source, you remain obligated to ensure that it is
    available for as long as needed to satisfy these requirements.

e) Convey the object code using peer-to-peer transmission, provided
    you inform other peers where the object code and Corresponding
    Source of the work are being offered to the general public at no
    charge under subsection 6d.

A separable portion of the object code, whose source code is excluded
from the Corresponding Source as a System Library, need not be
included in conveying the object code work.

A "User Product" is either (1) a "consumer product", which means any
tangible personal property which is normally used for personal, family,
or household purposes, or (2) anything designed or sold for incorporation
into a dwelling.  In determining whether a product is a consumer product,
doubtful cases shall be resolved in favor of coverage.  For a particular
product received by a particular user, "normally used" refers to a
typical or common use of that class of product, regardless of the status
of the particular user or of the way in which the particular user
actually uses, or expects or is expected to use, the product.  A product
is a consumer product regardless of whether the product has substantial
commercial, industrial or non-consumer uses, unless such uses represent
the only significant mode of use of the product.

"Installation Information" for a User Product means any methods,
procedures, authorization keys, or other information required to install
and execute modified versions of a covered work in that User Product from
a modified version of its Corresponding Source.  The information must
suffice to ensure that the continued functioning of the modified object
code is in no case prevented or interfered with solely because
modification has been made.

If you convey an object code work under this section in, or with, or
specifically for use in, a User Product, and the conveying occurs as
part of a transaction in which the right of possession and use of the
User Product is transferred to the recipient in perpetuity or for a
fixed term (regardless of how the transaction is characterized), the
Corresponding Source conveyed under this section must be accompanied
by the Installation Information.  But this requirement does not apply
if neither you nor any third party retains the ability to install
modified object code on the User Product (for example, the work has
been installed in ROM).

The requirement to provide Installation Information does not include a
requirement to continue to provide support service, warranty, or updates
for a work that has been modified or installed by the recipient, or for
the User Product in which it has been modified or installed.  Access to a
network may be denied when the modification itself materially and
adversely affects the operation of the network or violates the rules and
protocols for communication across the network.

Corresponding Source conveyed, and Installation Information provided,
in accord with this section must be in a format that is publicly
documented (and with an implementation available to the public in
source code form), and must require no special password or key for
unpacking, reading or copying.

7. Additional Terms.

"Additional permissions" are terms that supplement the terms of this
License by making exceptions from one or more of its conditions.
Additional permissions that are applicable to the entire Program shall
be treated as though they were included in this License, to the extent
that they are valid under applicable law.  If additional permissions
apply only to part of the Program, that part may be used separately
under those permissions, but the entire Program remains governed by
this License without regard to the additional permissions.

When you convey a copy of a covered work, you may at your option
remove any additional permissions from that copy, or from any part of
it.  (Additional permissions may be written to require their own
removal in certain cases when you modify the work.)  You may place
additional permissions on material, added by you to a covered work,
for which you have or can give appropriate copyright permission.

Notwithstanding any other provision of this License, for material you
add to a covered work, you may (if authorized by the copyright holders of
that material) supplement the terms of this License with terms:

a) Disclaiming warranty or limiting liability differently from the
    terms of sections 15 and 16 of this License; or

b) Requiring preservation of specified reasonable legal notices or
    author attributions in that material or in the Appropriate Legal
    Notices displayed by works containing it; or

c) Prohibiting misrepresentation of the origin of that material, or
    requiring that modified versions of such material be marked in
    reasonable ways as different from the original version; or

d) Limiting the use for publicity purposes of names of licensors or
    authors of the material; or

e) Declining to grant rights under trademark law for use of some
    trade names, trademarks, or service marks; or

f) Requiring indemnification of licensors and authors of that
    material by anyone who conveys the material (or modified versions of
    it) with contractual assumptions of liability to the recipient, for
    any liability that these contractual assumptions directly impose on
    those licensors and authors.

All other non-permissive additional terms are considered "further
restrictions" within the meaning of section 10.  If the Program as you
received it, or any part of it, contains a notice stating that it is
governed by this License along with a term that is a further
restriction, you may remove that term.  If a license document contains
a further restriction but permits relicensing or conveying under this
License, you may add to a covered work material governed by the terms
of that license document, provided that the further restriction does
not survive such relicensing or conveying.

If you add terms to a covered work in accord with this section, you
must place, in the relevant source files, a statement of the
additional terms that apply to those files, or a notice indicating
where to find the applicable terms.

Additional terms, permissive or non-permissive, may be stated in the
form of a separately written license, or stated as exceptions;
the above requirements apply either way.

8. Termination.

You may not propagate or modify a covered work except as expressly
provided under this License.  Any attempt otherwise to propagate or
modify it is void, and will automatically terminate your rights under
this License (including any patent licenses granted under the third
paragraph of section 11).

However, if you cease all violation of this License, then your
license from a particular copyright holder is reinstated (a)
provisionally, unless and until the copyright holder explicitly and
finally terminates your license, and (b) permanently, if the copyright
holder fails to notify you of the violation by some reasonable means
prior to 60 days after the cessation.

Moreover, your license from a particular copyright holder is
reinstated permanently if the copyright holder notifies you of the
violation by some reasonable means, this is the first time you have
received notice of violation of this License (for any work) from that
copyright holder, and you cure the violation prior to 30 days after
your receipt of the notice.

Termination of your rights under this section does not terminate the
licenses of parties who have received copies or rights from you under
this License.  If your rights have been terminated and not permanently
reinstated, you do not qualify to receive new licenses for the same
material under section 10.

9. Acceptance Not Required for Having Copies.

You are not required to accept this License in order to receive or
run a copy of the Program.  Ancillary propagation of a covered work
occurring solely as a consequence of using peer-to-peer transmission
to receive a copy likewise does not require acceptance.  However,
nothing other than this License grants you permission to propagate or
modify any covered work.  These actions infringe copyright if you do
not accept this License.  Therefore, by modifying or propagating a
covered work, you indicate your acceptance of this License to do so.

10. Automatic Licensing of Downstream Recipients.

Each time you convey a covered work, the recipient automatically
receives a license from the original licensors, to run, modify and
propagate that work, subject to this License.  You are not responsible
for enforcing compliance by third parties with this License.

An "entity transaction" is a transaction transferring control of an
organization, or substantially all assets of one, or subdividing an
organization, or merging organizations.  If propagation of a covered
work results from an entity transaction, each party to that
transaction who receives a copy of the work also receives whatever
licenses to the work the party's predecessor in interest had or could
give under the previous paragraph, plus a right to possession of the
Corresponding Source of the work from the predecessor in interest, if
the predecessor has it or can get it with reasonable efforts.

You may not impose any further restrictions on the exercise of the
rights granted or affirmed under this License.  For example, you may
not impose a license fee, royalty, or other charge for exercise of
rights granted under this License, and you may not initiate litigation
(including a cross-claim or counterclaim in a lawsuit) alleging that
any patent claim is infringed by making, using, selling, offering for
sale, or importing the Program or any portion of it.

11. Patents.

A "contributor" is a copyright holder who authorizes use under this
License of the Program or a work on which the Program is based.  The
work thus licensed is called the contributor's "contributor version".

A contributor's "essential patent claims" are all patent claims
owned or controlled by the contributor, whether already acquired or
hereafter acquired, that would be infringed by some manner, permitted
by this License, of making, using, or selling its contributor version,
but do not include claims that would be infringed only as a
consequence of further modification of the contributor version.  For
purposes of this definition, "control" includes the right to grant
patent sublicenses in a manner consistent with the requirements of
this License.

Each contributor grants you a non-exclusive, worldwide, royalty-free
patent license under the contributor's essential patent claims, to
make, use, sell, offer for sale, import and otherwise run, modify and
propagate the contents of its contributor version.

In the following three paragraphs, a "patent license" is any express
agreement or commitment, however denominated, not to enforce a patent
(such as an express permission to practice a patent or covenant not to
sue for patent infringement).  To "grant" such a patent license to a
party means to make such an agreement or commitment not to enforce a
patent against the party.

If you convey a covered work, knowingly relying on a patent license,
and the Corresponding Source of the work is not available for anyone
to copy, free of charge and under the terms of this License, through a
publicly available network server or other readily accessible means,
then you must either (1) cause the Corresponding Source to be so
available, or (2) arrange to deprive yourself of the benefit of the
patent license for this particular work, or (3) arrange, in a manner
consistent with the requirements of this License, to extend the patent
license to downstream recipients.  "Knowingly relying" means you have
actual knowledge that, but for the patent license, your conveying the
covered work in a country, or your recipient's use of the covered work
in a country, would infringe one or more identifiable patents in that
country that you have reason to believe are valid.

If, pursuant to or in connection with a single transaction or
arrangement, you convey, or propagate by procuring conveyance of, a
covered work, and grant a patent license to some of the parties
receiving the covered work authorizing them to use, propagate, modify
or convey a specific copy of the covered work, then the patent license
you grant is automatically extended to all recipients of the covered
work and works based on it.

A patent license is "discriminatory" if it does not include within
the scope of its coverage, prohibits the exercise of, or is
conditioned on the non-exercise of one or more of the rights that are
specifically granted under this License.  You may not convey a covered
work if you are a party to an arrangement with a third party that is
in the business of distributing software, under which you make payment
to the third party based on the extent of your activity of conveying
the work, and under which the third party grants, to any of the
parties who would receive the covered work from you, a discriminatory
patent license (a) in connection with copies of the covered work
conveyed by you (or copies made from those copies), or (b) primarily
for and in connection with specific products or compilations that
contain the covered work, unless you entered into that arrangement,
or that patent license was granted, prior to 28 March 2007.

Nothing in this License shall be construed as excluding or limiting
any implied license or other defenses to infringement that may
otherwise be available to you under applicable patent law.

12. No Surrender of Others' Freedom.

If conditions are imposed on you (whether by court order, agreement or
otherwise) that contradict the conditions of this License, they do not
excuse you from the conditions of this License.  If you cannot convey a
covered work so as to satisfy simultaneously your obligations under this
License and any other pertinent obligations, then as a consequence you may
not convey it at all.  For example, if you agree to terms that obligate you
to collect a royalty for further conveying from those to whom you convey
the Program, the only way you could satisfy both those terms and this
License would be to refrain entirely from conveying the Program.

13. Use with the GNU Affero General Public License.

Notwithstanding any other provision of this License, you have
permission to link or combine any covered work with a work licensed
under version 3 of the GNU Affero General Public License into a single
combined work, and to convey the resulting work.  The terms of this
License will continue to apply to the part which is the covered work,
but the special requirements of the GNU Affero General Public License,
section 13, concerning interaction through a network will apply to the
combination as such.

14. Revised Versions of this License.

The Free Software Foundation may publish revised and/or new versions of
the GNU General Public License from time to time.  Such new versions will
be similar in spirit to the present version, but may differ in detail to
address new problems or concerns.

Each version is given a distinguishing version number.  If the
Program specifies that a certain numbered version of the GNU General
Public License "or any later version" applies to it, you have the
option of following the terms and conditions either of that numbered
version or of any later version published by the Free Software
Foundation.  If the Program does not specify a version number of the
GNU General Public License, you may choose any version ever published
by the Free Software Foundation.

If the Program specifies that a proxy can decide which future
versions of the GNU General Public License can be used, that proxy's
public statement of acceptance of a version permanently authorizes you
to choose that version for the Program.

Later license versions may give you additional or different
permissions.  However, no additional obligations are imposed on any
author or copyright holder as a result of your choosing to follow a
later version.

15. Disclaimer of Warranty.

THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
ALL NECESSARY SERVICING, REPAIR OR CORRECTION.

16. Limitation of Liability.

IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
SUCH DAMAGES.

17. Interpretation of Sections 15 and 16.

If the disclaimer of warranty and limitation of liability provided
above cannot be given local legal effect according to their terms,
reviewing courts shall apply local law that most closely approximates
an absolute waiver of all civil liability in connection with the
Program, unless a warranty or assumption of liability accompanies a
copy of the Program in return for a fee.

END OF TERMS AND CONDITIONS

How to Apply These Terms to Your New Programs

If you develop a new program, and you want it to be of the greatest
possible use to the public, the best way to achieve this is to make it
free software which everyone can redistribute and change under these terms.

To do so, attach the following notices to the program.  It is safest
to attach them to the start of each source file to most effectively
state the exclusion of warranty; and each file should have at least
the "copyright" line and a pointer to where the full notice is found.

<one line to give the program's name and a brief idea of what it does.>
    Copyright (C) <year>  <name of author>

This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

You should have received a copy of the GNU General Public License
    along with this program.  If not, see <https://www.gnu.org/licenses/>.

Also add information on how to contact you by electronic and paper mail.

If the program does terminal interaction, make it output a short
notice like this when it starts in an interactive mode:

<program>  Copyright (C) <year>  <name of author>
    This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
    This is free software, and you are welcome to redistribute it
    under certain conditions; type `show c' for details.

The hypothetical commands `show w' and `show c' should show the appropriate
parts of the General Public License.  Of course, your program's commands
might be different; for a GUI interface, you would use an "about box".

You should also get your employer (if you work as a programmer) or school,
if any, to sign a "copyright disclaimer" for the program, if necessary.
For more information on this, and how to apply and follow the GNU GPL, see
<https://www.gnu.org/licenses/>.

The GNU General Public License does not permit incorporating your program
into proprietary programs.  If your program is a subroutine library, you
may consider it more useful to permit linking proprietary applications with
the library.  If this is what you want to do, use the GNU Lesser General
Public License instead of this License.  But first, please read
<https://www.gnu.org/licenses/why-not-lgpl.html>.
07070100000007000081A4000000000000000000000001654939DE0000084D000000000000000000000000000000000000002500000000harec-1699297758.b4dd427/MAINTAINERSGuidelines for subsystem maintainers
------------------------------------

Maintainers have write access to hare-announce, make use of it to announce
notable or breaking API changes.

Any changes which affect modules outside of your jurisdiction should be subject
to some general review before being pushed upstream.

Descriptions of section entries and preferred order
---------------------------------------------------

M: *Mail* patches to: FullName <address@domain>
	R: Designated *Reviewer*: FullName <address@domain>
	   These reviewers should be CCed on patches.
	L: *Mailing list* that is relevant to this area
	W: *Web-page* with status/info
	C: URI for *chat* protocol, server and channel where developers
	   usually hang out, for example irc://server/channel.
	P: Subsystem Profile document for more details submitting
	   patches to the given subsystem. This is either an in-tree file,
	   or a URI.
	T: *SCM* tree location.
	F: *Files* and directories wildcard patterns.
	   A trailing slash includes all files and subdirectory files.
	   F:	drivers/net/	all files in and below drivers/net
	   F:	drivers/net/*	all files in drivers/net, but not below
	   F:	*/net/*		all files in "any top level directory"/net
	   One pattern per line.  Multiple F: lines acceptable.
	X: *Excluded* files and directories that are NOT maintained, same
	   rules as F:. Files exclusions are tested before file matches.
	   Can be useful for excluding a specific subdirectory, for instance:
	   F:	net/
	   X:	net/ipv6/
	   matches all files in and below net excluding net/ipv6/

Maintainers List
----------------

.. note:: When reading this list, please look for the most precise areas
          first. When adding to this list, please keep the entries in
          alphabetical order.

OPENBSD SUPPORT
M:	Lennart Jablonka <humm@ljabl.com>
T:	*+openbsd*

THE REST
M:	Drew DeVault <sir@cmpwn.com>
M:	Ember Sawady <ecs@d2evs.net>
M:	Sebastian <sebastian@sebsite.pw>
M:	Bor Grošelj Simić <bgs@turminal.net>
L:	~sircmpwn/hare-dev@lists.sr.ht
T:	git https://git.sr.ht/~sircmpwn/harec
C:	irc://irc.libera.chat/#hare-dev
F:	*
F:	*/
07070100000008000081A4000000000000000000000001654939DE00000266000000000000000000000000000000000000002200000000harec-1699297758.b4dd427/Makefile.POSIX:
.SUFFIXES:
OUTDIR=.build
include $(OUTDIR)/config.mk

harec: $(harec_objects)
	@printf 'CCLD\t$@\n'
	@$(CC) $(LDFLAGS) -o $@ $(harec_objects) $(LIBS)

hare_env=

include rt/Makefile
include testmod/Makefile
include tests/Makefile

.SUFFIXES: .c .o .ha .s .scd .1 .5

.c.o:
	@printf 'CC\t$@\n'
	@$(CC) -c $(CFLAGS) -o $@ $<

.s.o:
	@printf 'AS\t$@\n'
	@$(AS) -o $@ $<

clean: clean-tests clean-rt clean-testmod
	@rm -f harec $(harec_objects)

distclean: clean
	@rm -rf "$(OUTDIR)"

install: harec
	mkdir -p $(DESTDIR)$(BINDIR)
	install -m755 harec $(DESTDIR)$(BINDIR)/harec

.PHONY: clean distclean install
07070100000009000081A4000000000000000000000001654939DE000004D1000000000000000000000000000000000000002300000000harec-1699297758.b4dd427/README.md# harec

This is a [Hare](https://harelang.org) compiler written in C11 for
POSIX-compatible systems.

## Build status

<dl>
  <dt>Linux (x86_64)</dt><dd><a href="https://builds.sr.ht/~sircmpwn/harec/commits/master/alpine.yml"><img src="https://builds.sr.ht/~sircmpwn/harec/commits/master/alpine.yml.svg" alt="Build status for Linux" /></a></dd>
  <dt>FreeBSD (x86_64)</dt><dd><a href="https://builds.sr.ht/~sircmpwn/harec/commits/master/freebsd.yml"><img src="https://builds.sr.ht/~sircmpwn/harec/commits/master/freebsd.yml.svg" alt="Build status for FreeBSD" /></a></dd>
  <dt>NetBSD (x86_64)</dt><dd><a href="https://builds.sr.ht/~sircmpwn/harec/commits/master/netbsd.yml"><img src="https://builds.sr.ht/~sircmpwn/harec/commits/master/netbsd.yml.svg" alt="Build status for NetBSD" /></a></dd>
</dl>

## Building

```
mkdir build
cd build
../configure
make
```

Optionally, build and run the test suite as well:

```
make check
```

## Runtime

harec includes a minimal runtime under `rt` which is suitable for running the
test suite, but not recommended for production use. See `docs/runtime.txt` for
details on how to provide your own runtime implementation, or use the [Hare
standard library](https://git.sr.ht/~sircmpwn/hare).
0707010000000A000081A4000000000000000000000001654939DE000013F3000000000000000000000000000000000000002300000000harec-1699297758.b4dd427/config.shoutdir=${OUTDIR:-.build}
srcdir=${SRCDIR:-$(dirname "$0")}
AR=${AR:-ar}
AS=${AS:-as}
CC=${CC:-cc}
CFLAGS=${CFLAGS:-}
DEFAULT_TARGET=
LDFLAGS=${LDFLAGS:-}
LD=${LD:-ld}
QBE=${QBE:-qbe}

if [ `uname -s` = "OpenBSD" ]
then
	LD="${LD:-ld} -nopie"
fi

for arg
do
	case "$arg" in
		--bindir=*)
			BINDIR=${arg#*=}
			;;
		--libdir=*)
			LIBDIR=${arg#*=}
			;;
		--mandir=*)
			MANDIR=${arg#*=}
			;;
		--prefix=*)
			PREFIX=${arg#*=}
			if [ "$PREFIX" = "/usr" ]
			then
				SYSCONFDIR=/etc
			fi
			;;
		--sharedir=*)
			SHAREDIR=${arg#*=}
			;;
		--sysconfdir=*)
			SYSCONFDIR=${arg#*=}
			;;
		--target=*)
			DEFAULT_TARGET=${arg#*=}
			;;
		--help)
			cat >&2 <<'EOF'
Usage: configure [options...]

Options:
--help
--prefix=<path>
	default: /usr/local
--bindir=<path>
	default: (prefix)/bin
--libdir=<path>
	default: (prefix)/lib
--mandir=<path>
	default: (prefix)/share/man
--sharedir=<path>
	default: (prefix)/share
--sysconfdir=<path>
	default: /etc if prefix is /usr, otherwise (prefix)/etc
--target=<arch>
	default: (current arch)

Environment variables:
AR	(default: "ar")
AS	(default: "as")
CC	(default: "cc")
CFLAGS	(default: "")
LD	(default: "ld")
LDFLAGS	(default: "")
OUTDIR	(default: ".build")
QBE	(default: "qbe")
SRCDIR	(default: directory of configure script)
EOF
			exit
			;;
		*)
			printf 'Error: unknown configure option %s\n' "$arg" >&2
			exit 1
			;;
	esac
done

subdir() {
	eval ". $srcdir/$1/configure"
}

headers() {
	printf 'HEADERS=\\\n'
	while [ $# -ne 0 ]
	do
		printf '\tinclude/%s \\\n' "$1"
		shift
	done
}

genrules() {
	target="$1"
	shift
	printf '# Begin generated rules for %s\n' "$target"
	for file in "$@"
	do
		ext="${file#*.}"
		file="${file%.*}"
		deps=
		if [ $ext = "ha" ]
		then
			deps=" harec"
		fi
		printf '%s.o: %s.%s%s $(HEADERS)\n' "$file" "$file" "$ext" "$deps"
	done
	printf '%s_objects=\\\n' "$target"
	n=0
	for file in "$@"
	do
		file="${file%.*}"
		n=$((n+1))
		if [ $n -eq $# ]
		then
			printf '\t%s.o\n' "$file"
		else
			printf '\t%s.o \\\n' "$file"
		fi
	done
	printf '# End generated rules for %s\n' "$target"
}

append_cflags() {
	for flag
	do
		CFLAGS="$(printf '%s \\\n\t%s' "$CFLAGS" "$flag")"
	done
}

test_cflags() {
	[ ! -e "$outdir"/check.c ] && cat <<-EOF > "$outdir"/check.c
	int main(void) { return 0; }
	EOF
	werror=""
	case "$CFLAGS" in
		*-Werror*)
			werror="-Werror"
			;;
	esac
	if $CC $werror "$@" -o /dev/null "$outdir"/check.c >/dev/null 2>&1
	then
		append_cflags "$@"
	else
		return 1
	fi
}

find_library() {
	name="$1"
	pc="$2"
	printf "Checking for %s... " "$name"
	if ! pkg-config "$pc" 2>/dev/null
	then
		printf "NOT FOUND\n"
		printf "Tried pkg-config %s\n" "$pc"
		return 1
	fi
	printf "OK\n"
	CFLAGS="$CFLAGS $(pkg-config --cflags "$pc")"
	LIBS="$LIBS $(pkg-config --libs "$pc")"
}

run_configure() {
	mkdir -p "$outdir"

for flag in -g -std=c11 -D_XOPEN_SOURCE=700 \
		-Wall -Wextra -Werror -pedantic \
		-Wno-unused-parameter
	do
		printf "Checking for %s... " "$flag"
		if test_cflags "$flag"
		then
			echo yes
		else
			echo no
		fi
	done

if [ -z "$DEFAULT_TARGET" ]
	then
		printf "Detecting machine architecture... "
		arch="$(uname -m)"
		case "$arch" in
			x86_64|amd64)
				DEFAULT_TARGET=x86_64
				;;
			aarch64|arm64)
				DEFAULT_TARGET=aarch64
				;;
			riscv64)
				DEFAULT_TARGET=riscv64
				;;
			*)
				printf "Error: unsupported or unrecognized architecture %s\n" "$arch"
				;;
		esac
		printf '%s\n' "$DEFAULT_TARGET"
	fi
	append_cflags -DDEFAULT_TARGET="\\\"$DEFAULT_TARGET\\\""

printf "Checking for qbe... "
	if $QBE -h > /dev/null 2>&1
	then
		echo yes
	else
		echo no
		echo "Error: no qbe binary found"
		exit 1
	fi

printf "Creating %s/config.mk... " "$outdir"
	cat <<EOF > "$outdir"/config.mk
CC=$CC
AS=$AS
LD=$LD
AR=$AR
QBE=$QBE
LIBS=$LIBS -lm
PREFIX=${PREFIX:-/usr/local}
OUTDIR=${outdir}
SRCDIR=${srcdir}
BINDIR=${BINDIR:-\$(PREFIX)/bin}
SHAREDIR=${SHAREDIR:-\$(PREFIX)/share}
SYSCONFDIR=${SYSCONFDIR:-\$(PREFIX)/etc}
LIBDIR=${LIBDIR:-\$(PREFIX)/lib}
MANDIR=${MANDIR:-\$(PREFIX)/share/man}
VARLIBDIR=${MANDIR:-\$(PREFIX)/var/lib}
CACHE=\$(OUTDIR)/cache
CFLAGS=${CFLAGS} \\
	-Iinclude -I\$(OUTDIR) \\
	-DPREFIX='"\$(PREFIX)"' \\
	-DLIBDIR='"\$(LIBDIR)"' \\
	-DVARLIBDIR='"\$(VARLIBDIR)"' \\
	-DSYSCONFDIR='"\$(SYSCONFDIR)"' \\
	-DVERSION='"'"\$\$(./scripts/version)"'"'
LDFLAGS=${LDFLAGS}
HARECACHE=./mod

all: ${all}
EOF

for target in $all
	do
		$target >>"$outdir"/config.mk
	done
	echo done

cat <<-EOF >harec.sh
	export PATH="$(pwd)":\$PATH
	EOF

if [ "$srcdir" = "." ]
	then
		return
	fi

populate() (
		path="$1"
		mkdir -p "${path#$srcdir/}"
		fullpath() ( cd "$1" && pwd )
		for orig in "$path"/*
		do
			link="${orig#$srcdir/}"
			if [ -d "$orig" ]
			then
				mkdir -p $link
				populate "$orig"
			elif [ -f "$orig" ]
			then
				ln -sf "$(fullpath "$path")"/"$(basename "$orig")" "$link"
			fi
		done
	)

printf "Populating build dir... "
	populate "$srcdir/doc"
	populate "$srcdir/include"
	populate "$srcdir/rt"
	populate "$srcdir/scripts"
	populate "$srcdir/src"
	populate "$srcdir/tests"
	populate "$srcdir/testmod"
	ln -sf "$srcdir"/Makefile ./
	echo done
}
0707010000000B000081ED000000000000000000000001654939DE000002C2000000000000000000000000000000000000002300000000harec-1699297758.b4dd427/configure#!/bin/sh -e
srcdir=${SRCDIR:-$(dirname "$0")}

eval ". $srcdir/config.sh"

harec() {
	headers \
		"ast.h" \
		"check.h" \
		"emit.h" \
		"eval.h" \
		"expr.h" \
		"gen.h" \
		"identifier.h" \
		"lex.h" \
		"mod.h" \
		"parse.h" \
		"qbe.h" \
		"scope.h" \
		"type_store.h" \
		"typedef.h" \
		"types.h" \
		"utf8.h" \
		"util.h"
	genrules harec \
		src/check.c \
		src/emit.c \
		src/eval.c \
		src/gen.c \
		src/genutil.c \
		src/identifier.c \
		src/lex.c \
		src/main.c \
		src/mod.c \
		src/parse.c \
		src/qbe.c \
		src/qinstr.c \
		src/qtype.c \
		src/scope.c \
		src/type_store.c \
		src/typedef.c \
		src/types.c \
		src/utf8.c \
		src/util.c
}

all="harec"

subdir rt
subdir tests

run_configure
0707010000000C000041ED000000000000000000000002654939DE00000000000000000000000000000000000000000000001E00000000harec-1699297758.b4dd427/docs0707010000000D000081A4000000000000000000000001654939DE0000129E000000000000000000000000000000000000003500000000harec-1699297758.b4dd427/docs/declaration_solver.txtFirst thing harec does after parsing the inputs is making sure all the global
declarations are valid. A constraint unique to this compilation step is that
unlike with sequential bindings in a compound expression, there is no explicit
order in which the declarations should be traversed to validate them, the
correct traversal order is given by the contents of declarations themselves. To
make things even more complex, interdependent declarations may reside in
different subunits, so there is quite a bit of scope juggling involved to
achieve correct scope shadowing.

Declarations come in five flavours - functions, constants, type aliases, global
variables and enum fields.

First, the constants defined upon harec invocation are checked and put into a
dedicated scope. Then the imports for each subunit are loaded. This step requires
the command line defines to already be in place. After the imports of a
subunit are loaded, all of its declarations except enums are marked
incomplete and put into the unit scope. Duplicate declarations are caught and
reported at this step. Enum types are treated separately from enum values
in this algorithm. Enum types never have dependencies and can be completed
on the spot. Enum values are put into a special scope that is created for each
enum type and marked incomplete.

At this point the dedicated scope for defines is reparented on the unit
scope, shadowing the declarations from the source files.

Next, aliases of enum types are detected and taken care of. Because an enum
alias only depends on the underlying enum type, its entire dependency tree
is known immediately when it is detected, so it can be completed right away.
For values of enum aliases we need to cover three possible configurations:
    (a) An alias to an enum whose values are already completed at this stage.
	This happens when the underlying enum was imported from another module.
	This is the easiest case to handle, we can just copy it's values to the
	alias immediately.
    (b) An enum alias whose underlying enum is defined in the same unit this
	case is handled by the general resolution algorithm described below.

With everything but the declarations in place, the core part of the algorithm
is started:

For each incomplete declaration:
    (1) Save previous enum and subunit context, and load subunit context for
        current declaration.
    (2) If this declaration is marked as in-progress, error out because the
        declaration part of a dependency cycle, otherwise mark this
        declaration as in progress.
    (3) Disambiguate between different declaration flavours:
        - for functions, constants and globals and enum fields:
            Check and evaluate as if all the dependencies are already resolved.
            For enum fields, the relevant enum context has to be loaded and
            implicit values need to be taken care of.

If an incomplete dependency is encountered along the way, first
            resolve that dependency recursively and then continue with
            resolution. When the check is done, insert the declaration into the
            unit scope. Declaration is now considered complete.
        - for type aliases:
            Types have two distinct properties that both have to be computed
            before a type is complete, their dimensions and their
            representation. The approach taken can be summarized as follows:

(a) Compute secondary type's dimensions by traversing just enough
                of its constituent types to be able to do so.  If an incomplete
                type alias is encountered, first compute that type's dimensions
                recursively and then continue.
            (b) Insert the complete alias into the type store and into the unit
                scope.
            (c) Compute secondary type's representation by traversing all of
                its constituent types and repeating this entire process on
                those that are still incomplete.

A valid type alias never references itself during (a), because such
            a type would not be storable in memory.  Types may reference
            themselves during (c). Such types are called self-referential
            types. Self-references during (c) require no special treatment,
            because from step (b) onwards the type we are currently declaring
            can be treated as a regular complete type.
    (4) Remove the in progress mark
    (5) Restore the saved subunit and enum context

At this point all the incomplete declarations in the unit scope are shadowed by
their complete counterparts. From here on, no special considerations regarding
incomplete declarations apply and check can proceed accordingly.
0707010000000E000081A4000000000000000000000001654939DE0000036D000000000000000000000000000000000000002600000000harec-1699297758.b4dd427/docs/env.txtharec uses environment variables to find typedef files for modules referenced in
the current unit (including transitive dependencies). The user is responsible
for building dependencies first and ensuring that they appear in the
environment. The variable HARE_TD_$MOD should contain the path where harec can
find the typedef file for the module $MOD. For example, if
HARE_TD_encoding::utf8 contains the value "/tmp/encoding_utf8.td", harec would
expect /tmp/encoding_utf8.td to contain encoding::utf8's typedefs. If a module
is referenced without the associated environment variable being present, harec
will error out.

In addition, harec also recognizes the following environment variables:
- NO_COLOR: Disables color output when set to a non-empty string.
- HAREC_COLOR: Disables color output when set to 0, enables it when set to any
  other value. This overrides NO_COLOR.
0707010000000F000081A4000000000000000000000001654939DE00000B9A000000000000000000000000000000000000002A00000000harec-1699297758.b4dd427/docs/runtime.txtharec expects the runtime to provide some features under the "rt" namespace.

@symbol("rt.abort") fn _abort(path: *str, line: u64, col: u64, msg: str) void;
	Print a diagnostic message and terminate the program.

fn abort_fixed(path: *str, line: u64, col: u64, reason: u64) void;
	Print a diagnostic message from a list of pre-determined abort reasons,
	and terminate the program. The list of reasons are:

0: Slice or array access out-of-bounds
	1: Type assertion failed
	2: Out of memory
	3: Static append exceeds slice capacity
	4: Unreachable code
	5: Slice allocation capacity smaller than initializer
	6: Generic assertion failure without a message
	7: Error assertion failed

fn memcpy(dest: *opaque, src: *opaque, n: size) void;
	Copy "n" bytes from "src" to "dest". The memory areas shall not
	overlap.

fn memmove(dest: *opaque, src: *opaque, n: size) void;
	Copy "n" bytes from "src" to "dest". The memory areas may overlap.

fn memset(dest: *opaque, val: u8, n: size) void;
	Set "n" bytes, starting from the address at "dest", to "val".

fn strcmp(a: str, b: str) bool;
	Compare strings "a" and "b", returning true of they are equal.

"ensure" and "unensure" are called when slices are expanded or deleted. The
"length" field of the slice will have been updated, and ensure should allocate
or re-allocate the data field to have sufficient space, and update the capacity
field accordingly. "unensure" is called when the space is no longer needed, and
should shrink the allocation as appropriate.

type slice = struct {
		data: nullable *opaque,
		length: size,
		capacity: size,
	};

fn ensure(s: *slice, membsz: size) void;
	fn unensure(s: *slice, membsz: size) void;

"malloc" and "free" are required to support the "alloc" and "free" built-ins.

fn malloc(n: size) nullable *opaque;

@symbol("rt.free") fn free_(_p: nullable *opaque) void;

The runtime is also expected to provide startup code. A list of function
pointers of type `fn() void` is provided in the __init_array_start and
__fini_array_start globals, which are respectively terminated by
__init_array_end and __fini_array_end. The following Hare code will make these
globals available to the current unit:

const @symbol("__init_array_start") init_start: [*]*fn() void;
	const @symbol("__init_array_end") init_end: [*]*fn() void;
	const @symbol("__fini_array_start") fini_start: [*]*fn() void;
	const @symbol("__fini_array_end") fini_end: [*]*fn() void;

When building with +test (harec -T), @test functions will be emitted, and an ELF
section, .test_array, will be populated similarly to init_array. The startup
code can enumerate the available tests like so:

type test = struct {
		name: str,
		func: *fn() void,
	};

const @symbol("__test_array_start") test_start: [*]test;
	const @symbol("__test_array_end") test_end: [*]test;

In order to use these symbols, a custom linker script must be used. A sample is
provided in rt/hare.sc which is compatible with GNU's ld and LLVM's lld.
07070100000010000041ED000000000000000000000002654939DE00000000000000000000000000000000000000000000002100000000harec-1699297758.b4dd427/include07070100000011000081A4000000000000000000000001654939DE000021AE000000000000000000000000000000000000002700000000harec-1699297758.b4dd427/include/ast.h#ifndef HARE_AST_H
#define HARE_AST_H
#include <stdbool.h>
#include <stdint.h>
#include "expr.h"
#include "identifier.h"
#include "lex.h"
#include "types.h"

struct ast_type;

enum ast_import_mode_flags {
	AST_IMPORT_ALIAS = 1 << 0,	// use foo::bar = x::y;
	AST_IMPORT_MEMBERS = 1 << 1,	// use foo::bar::{a, b, c};
	AST_IMPORT_WILDCARD = 1 << 2,	// use foo::bar::*;
};

struct ast_imports {
	struct location loc;
	enum ast_import_mode_flags mode;
	struct identifier ident;
	struct identifier *alias;
	struct ast_imports *members;
	struct ast_imports *next;
};

struct ast_list_type {
	struct ast_expression *length; // NULL for slices and unbounded arrays
	struct ast_type *members;
	bool contextual;
};

struct ast_enum_field {
	struct location loc;
	const char *name;
	struct ast_expression *value;
	struct ast_enum_field *next;
};

struct ast_enum_type {
	enum type_storage storage;
	struct ast_enum_field *values;
};

struct ast_function_parameters {
	struct location loc;
	char *name;
	struct ast_type *type;
	struct ast_function_parameters *next;
};

struct ast_function_type {
	struct ast_type *result;
	struct ast_function_parameters *params;
	enum variadism variadism;
};

struct ast_pointer_type {
	struct ast_type *referent;
	unsigned int flags;
};

struct ast_tagged_union_type {
	struct ast_type *type;
	struct ast_tagged_union_type *next;
};

struct ast_tuple_type {
	struct ast_type *type;
	struct ast_tuple_type *next;
};

struct ast_struct_union_field {
	struct ast_struct_union_field *next;
	struct ast_expression *offset;
	char *name;
	struct ast_type *type;
};

struct ast_struct_union_type {
	struct ast_struct_union_field fields;
	bool packed;
};

struct ast_type {
	struct location loc;
	enum type_storage storage;
	unsigned int flags;
	union {
		struct ast_list_type array;
		struct ast_function_type func;
		struct ast_pointer_type pointer;
		struct ast_list_type slice;
		struct ast_struct_union_type struct_union;
		struct ast_tagged_union_type tagged_union;
		struct ast_tuple_type tuple;
		struct {
			struct identifier alias;
			union {
				struct ast_enum_type _enum;
				bool unwrap;
			};
		};
	};
};

struct ast_expression_list {
	struct ast_expression *expr;
	struct ast_expression_list *next;
};

struct ast_expression_access {
	enum access_type type;
	union {
		struct identifier ident;
		struct {
			struct ast_expression *array;
			struct ast_expression *index;
		};
		struct {
			struct ast_expression *_struct;
			char *field;
		};
		struct {
			struct ast_expression *tuple;
			struct ast_expression *value;
		};
	};
};

struct ast_expression_alloc {
	enum alloc_kind kind;
	struct ast_expression *init;
	struct ast_expression *cap;
};

struct ast_expression_append {
	struct ast_expression *object;
	struct ast_expression *value;
	struct ast_expression *length;
	bool is_static, is_multi;
};

struct ast_expression_assert {
	struct ast_expression *cond;
	struct ast_expression *message;
	bool is_static;
};

struct ast_expression_assign {
	enum binarithm_operator op;
	struct ast_expression *object, *value;
};

struct ast_expression_binarithm {
	enum binarithm_operator op;
	struct ast_expression *lvalue, *rvalue;
};

struct ast_binding_unpack {
	char *name;
	struct ast_binding_unpack *next;
};

struct ast_expression_binding {
	char *name;
	struct ast_binding_unpack *unpack;
	struct ast_type *type;
	unsigned int flags;
	bool is_static;
	struct ast_expression *initializer;
	struct ast_expression_binding *next;
};

struct ast_call_argument {
	bool variadic;
	struct ast_expression *value;
	struct ast_call_argument *next;
};

struct ast_expression_call {
	struct ast_expression *lvalue;
	struct ast_call_argument *args;
};

struct ast_expression_cast {
	enum cast_kind kind;
	struct ast_expression *value;
	struct ast_type *type;
};

struct ast_array_constant {
	struct ast_expression *value;
	struct ast_array_constant *next;
	bool expand;
};

struct ast_expression_constant {
	enum type_storage storage;
	union {
		int64_t ival;
		uint64_t uval;
		double fval;
		uint32_t rune;
		bool bval;
		struct {
			size_t len;
			char *value;
		} string;
		struct ast_array_constant *array;
	};
};

struct ast_expression_control {
	char *label;
	struct ast_expression *value; // Only set for yield
};

struct ast_expression_defer {
	struct ast_expression *deferred;
};

struct ast_expression_delete {
	struct ast_expression *expr;
	bool is_static;
};

struct ast_expression_for {
	struct ast_expression *bindings;
	struct ast_expression *cond;
	struct ast_expression *afterthought;
	struct ast_expression *body;
};

struct ast_expression_free {
	struct ast_expression *expr;
};

struct ast_expression_if {
	struct ast_expression *cond;
	struct ast_expression *true_branch, *false_branch;
};

struct ast_expression_compound {
	char *label;
	struct location label_loc;
	struct ast_expression_list list;
};

struct ast_match_case {
	char *name; // May be null
	struct ast_type *type;
	struct ast_expression_list exprs;
	struct ast_match_case *next;
};

struct ast_expression_match {
	struct ast_expression *value;
	struct ast_match_case *cases;
};

struct ast_expression_measure {
	enum measure_operator op;
	union {
		struct ast_expression *value;
		struct ast_type *type;
		// TODO: Field selection
	};
};

struct ast_expression_propagate {
	struct ast_expression *value;
	bool abort;
};

struct ast_expression_return {
	struct ast_expression *value;
};

struct ast_expression_slice {
	struct ast_expression *object;
	struct ast_expression *start, *end;
};

struct ast_case_option {
	struct ast_expression *value;
	struct ast_case_option *next;
};

struct ast_switch_case {
	struct ast_case_option *options; // NULL for *
	struct ast_expression_list exprs;
	struct ast_switch_case *next;
};

struct ast_expression_switch {
	struct ast_expression *value;
	struct ast_switch_case *cases;
};

struct ast_expression_struct;

struct ast_field_value {
	char *name;
	struct ast_type *type;
	struct ast_expression *initializer;
	struct ast_field_value *next;
};

struct ast_expression_struct {
	bool autofill;
	struct identifier type;
	struct ast_field_value *fields;
};

struct ast_expression_tuple {
	struct ast_expression *expr;
	struct ast_expression_tuple *next;
};

struct ast_expression_unarithm {
	enum unarithm_operator op;
	struct ast_expression *operand;
};

struct ast_expression_vaarg {
	struct ast_expression *ap;
};

struct ast_expression {
	struct location loc;
	enum expr_type type;
	union {
		struct ast_expression_access access;
		struct ast_expression_alloc alloc;
		struct ast_expression_append append; // also insert
		struct ast_expression_assert assert;
		struct ast_expression_assign assign;
		struct ast_expression_binarithm binarithm;
		struct ast_expression_binding binding;
		struct ast_expression_call call;
		struct ast_expression_cast cast;
		struct ast_expression_compound compound;
		struct ast_expression_constant constant;
		struct ast_expression_control control;
		struct ast_expression_defer defer;
		struct ast_expression_delete delete;
		struct ast_expression_for _for;
		struct ast_expression_free free;
		struct ast_expression_if _if;
		struct ast_expression_match match;
		struct ast_expression_measure measure;
		struct ast_expression_propagate propagate;
		struct ast_expression_return _return;
		struct ast_expression_slice slice;
		struct ast_expression_struct _struct;
		struct ast_expression_switch _switch;
		struct ast_expression_tuple tuple;
		struct ast_expression_unarithm unarithm;
		struct ast_expression_vaarg vaarg;
	};
};

struct ast_global_decl {
	char *symbol;
	bool threadlocal;
	struct identifier ident;
	struct ast_type *type;
	struct ast_expression *init;
	struct ast_global_decl *next;
};

struct ast_type_decl {
	struct identifier ident;
	struct ast_type *type;
	struct ast_type_decl *next;
};

struct ast_function_decl {
	char *symbol;
	struct identifier ident;
	struct ast_function_type prototype;
	struct ast_expression *body;
	unsigned int flags; // enum func_decl_flags (check.h)
};

enum ast_decl_type {
	ADECL_FUNC,
	ADECL_TYPE,
	ADECL_GLOBAL,
	ADECL_CONST,
	ADECL_ASSERT,
};

struct ast_decl {
	struct location loc;
	enum ast_decl_type decl_type;
	bool exported;
	union {
		struct ast_global_decl global;
		struct ast_global_decl constant;
		struct ast_type_decl type;
		struct ast_function_decl function;
		struct ast_expression_assert assert;
	};
};

struct ast_decls {
	struct ast_decl decl;
	struct ast_decls *next;
};

struct ast_subunit {
	struct ast_imports *imports;
	struct ast_decls *decls;
	struct ast_subunit *next;
};

struct ast_unit {
	struct identifier *ns;
	struct ast_subunit subunits;
};

#endif
07070100000012000081A4000000000000000000000001654939DE00000E67000000000000000000000000000000000000002900000000harec-1699297758.b4dd427/include/check.h#ifndef HARE_CHECK_H
#define HARE_CHECK_H
#include <stdbool.h>
#include <stdnoreturn.h>
#include "identifier.h"
#include "scope.h"
#include "types.h"
#include "type_store.h"

struct expression;

#define MODCACHE_BUCKETS 256

struct modcache {
	struct identifier ident;
	struct scope *scope;
	struct modcache *next;
};

struct ast_expression;
struct ast_unit;

struct errors {
	struct location loc;
	char *msg;
	struct errors *next;
};

struct context {
	struct modcache **modcache;
	struct type_store *store;
	const struct type *fntype;
	struct identifier *ns;
	struct scope *unit;
	struct scope *scope;
	struct scope *defines;
	const char *mainsym;
	bool is_test;
	int id;
	struct errors *errors;
	struct errors **next;
	struct declarations *decls;
};

struct constant_decl {
	const struct type *type;
	const struct expression *value;
};

enum func_decl_flags {
	FN_FINI = 1 << 0,
	FN_INIT = 1 << 1,
	FN_TEST = 1 << 2,
};

struct function_decl {
	const struct type *type;
	struct expression *body;
	struct scope *scope;
	unsigned int flags; // enum func_decl_flags
};

struct global_decl {
	const struct type *type;
	struct expression *value; // EXPR_CONSTANT
	bool threadlocal;
};

enum decl_type {
	DECL_FUNC,
	DECL_TYPE,
	DECL_GLOBAL,
	DECL_CONST,
};

struct declaration {
	enum decl_type decl_type;
	int file;
	struct identifier ident;
	char *symbol;
	bool exported; // XXX: this bool takes up 8 bytes and i am in pain
	union {
		struct constant_decl constant;
		struct function_decl func;
		struct global_decl global;
		const struct type *type;
	};
};

struct declarations {
	struct declaration decl;
	struct declarations *next;
};

struct unit {
	struct identifier *ns;
	struct declarations *declarations;
	struct identifiers *imports;
};

enum idecl_type {
	IDECL_DECL,
	IDECL_ENUM_FLD,
};

// Keeps track of enum specific context required for enum field resolution
struct incomplete_enum_field {
	struct ast_enum_field *field;
	struct scope *enum_scope;
};

// Keeps track of context required to resolve a declaration or an enum field
// Extends the scope_object struct so it can be inserted into a scope
struct incomplete_declaration {
	struct scope_object obj;
	struct scope *imports; // the scope of this declaration's subunit
	enum idecl_type type;
	bool in_progress;
	bool dealias_in_progress;
	union {
		struct ast_decl decl;
		struct incomplete_enum_field *field;
	};
};

void mkident(struct context *ctx, struct identifier *out,
		const struct identifier *in, const char *symbol);

void mkstrconst(struct expression *expr, const char *fmt, ...);

char *gen_typename(const struct type *type);

typedef void (*resolvefn)(struct context *,
		struct incomplete_declaration *idecl);

void resolve_dimensions(struct context *ctx,
		struct incomplete_declaration *idecl);

void resolve_type(struct context *ctx,
		struct incomplete_declaration *idecl);

void wrap_resolver(struct context *ctx,
	struct scope_object *obj, resolvefn resolver);

struct scope *check(struct type_store *ts,
	bool is_test,
	const char *mainsym,
	struct ast_global_decl *defines,
	const struct ast_unit *aunit,
	struct unit *unit);

void check_expression(struct context *ctx,
	const struct ast_expression *aexpr,
	struct expression *expr,
	const struct type *hint);

void error(struct context *ctx, const struct location loc,
	struct expression *expr, const char *fmt, ...);

noreturn void error_norec(struct context *ctx, const struct location loc,
	const char *fmt, ...);
#endif
07070100000013000081A4000000000000000000000001654939DE0000007A000000000000000000000000000000000000002800000000harec-1699297758.b4dd427/include/emit.h#ifndef HAREC_EMIT_H
#define HAREC_EMIT_H

struct qbe_program;
void emit(struct qbe_program *program, FILE *out);

#endif
07070100000014000081A4000000000000000000000001654939DE000000F3000000000000000000000000000000000000002800000000harec-1699297758.b4dd427/include/eval.h#ifndef HAREC_EVAL_H
#define HAREC_EVAL_H
#include <stdbool.h>

struct expression;
struct context;

// Evaluates an expression at compile time.
bool eval_expr(struct context *ctx, const struct expression *in,
	struct expression *out);

#endif
07070100000015000081A4000000000000000000000001654939DE00001C71000000000000000000000000000000000000002800000000harec-1699297758.b4dd427/include/expr.h#ifndef HAREC_EXPR_H
#define HAREC_EXPR_H
#include <stdint.h>
#include "identifier.h"
#include "lex.h"
#include "types.h"

struct scope;
struct scope_object;

enum expr_type {
	EXPR_ACCESS,
	EXPR_ALLOC,
	EXPR_APPEND,
	EXPR_ASSERT,
	EXPR_ASSIGN,
	EXPR_BINARITHM,
	EXPR_BINDING,
	EXPR_BREAK,
	EXPR_CALL,
	EXPR_CAST,
	EXPR_COMPOUND,
	EXPR_CONSTANT,
	EXPR_CONTINUE,
	EXPR_DEFER,
	EXPR_DEFINE,
	EXPR_DELETE,
	EXPR_FOR,
	EXPR_FREE,
	EXPR_IF,
	EXPR_INSERT,
	EXPR_MATCH,
	EXPR_MEASURE,
	EXPR_PROPAGATE,
	EXPR_RETURN,
	EXPR_SLICE,
	EXPR_STRUCT,
	EXPR_SWITCH,
	EXPR_TUPLE,
	EXPR_UNARITHM,
	EXPR_VAARG,
	EXPR_VAEND,
	EXPR_VASTART,
	EXPR_YIELD,
};

struct expressions {
	struct expression *expr;
	struct expressions *next;
};

enum access_type {
	ACCESS_IDENTIFIER,
	ACCESS_INDEX,
	ACCESS_FIELD,
	ACCESS_TUPLE,
};

struct expression_access {
	enum access_type type;
	union {
		const struct scope_object *object;
		struct {
			struct expression *array;
			struct expression *index;
			bool bounds_checked;
		};
		struct {
			struct expression *_struct;
			const struct struct_field *field;
		};
		struct {
			struct expression *tuple;
			const struct type_tuple *tvalue;
			size_t tindex;
		};
	};
};

enum alloc_kind {
	ALLOC_OBJECT,	// alloc(42)
	ALLOC_WITH_CAP,	// alloc([], 42)
	ALLOC_WITH_LEN,	// alloc([0...], 42)
	ALLOC_COPY,	// alloc(x...);
};

struct expression_alloc {
	enum alloc_kind kind;
	struct expression *init;
	struct expression *cap;
};

struct expression_append {
	struct expression *object;
	struct expression *value;
	struct expression *length;
	bool is_static, is_multi;
};

enum fixed_aborts {
	ABORT_OOB = 0,
	ABORT_TYPE_ASSERTION = 1,
	ABORT_ALLOC_FAILURE = 2,
	ABORT_STATIC_EXCEEDED = 3,
	ABORT_UNREACHABLE = 4,
	ABORT_CAP_TOO_SMALL = 5,
	ABORT_ANON_ASSERTION_FAILED = 6,
	ABORT_PROPAGATE_ERROR_OCCURRED = 7,
};

struct expression_assert {
	struct expression *cond;
	struct expression *message;
	enum fixed_aborts fixed_reason;
};

enum binarithm_operator {
	BIN_BAND,	// &
	BIN_BOR,	// |
	BIN_DIV,	// /
	BIN_GREATER,	// >
	BIN_GREATEREQ,	// >=
	BIN_LAND,	// &&
	BIN_LEQUAL,	// ==
	BIN_LESS,	// <
	BIN_LESSEQ,	// <=
	BIN_LOR,	// ||
	BIN_LSHIFT,	// <<
	BIN_LXOR,	// ^^
	BIN_MINUS,	// -
	BIN_MODULO,	// %
	BIN_NEQUAL,	// !=
	BIN_PLUS,	// +
	BIN_RSHIFT,	// >>
	BIN_TIMES,	// *
	BIN_BXOR,	// ^
	BIN_LAST = BIN_BXOR,
};

struct expression_assign {
	enum binarithm_operator op;
	struct expression *object, *value;
};

struct expression_binarithm {
	enum binarithm_operator op;
	struct expression *lvalue, *rvalue;
};

struct binding_unpack {
	const struct scope_object *object;
	size_t offset;
	struct binding_unpack *next;
};

struct expression_binding {
	const struct scope_object *object;
	struct binding_unpack *unpack;
	struct expression *initializer;
	struct expression_binding *next;
};

enum cast_kind {
	C_CAST,
	C_ASSERTION,
	C_TEST,
};

struct expression_cast {
	enum cast_kind kind;
	const struct type *secondary;
	struct expression *value;
	bool lowered;
};

struct call_argument {
	struct expression *value;
	struct call_argument *next;
};

struct expression_call {
	struct expression *lvalue;
	struct call_argument *args;
};

struct expression_compound {
	char *label;
	struct scope *scope;
	struct expressions exprs;
};

struct array_constant {
	struct expression *value;
	struct array_constant *next;
};

// Invariant: these are sorted by field offset
struct struct_constant {
	const struct struct_field *field;
	struct expression *value;
	struct struct_constant *next;
};

struct tuple_constant {
	const struct type_tuple *field;
	struct expression *value;
	struct tuple_constant *next;
};

struct tagged_constant {
	const struct type *tag;
	struct expression *value;
};

struct expression_constant {
	// If non-null, ival is an offset from this object's address
	const struct scope_object *object;
	union {
		bool bval;
		double fval;
		int64_t ival;
		uint64_t uval;
		uint32_t rune;
		struct {
			size_t len;
			char *value;
		} string;
		struct array_constant *array;
		struct struct_constant *_struct;
		struct tuple_constant *tuple;
		struct tagged_constant tagged;
	};
};

struct expression_control {
	char *label;
	const struct scope *scope;
	struct expression *value; // Only set for yield
};

struct expression_defer {
	struct scope *scope;
	struct expression *deferred;
};

struct expression_delete {
	struct expression *expr;
	bool is_static;
};

struct expression_for {
	struct scope *scope;
	struct expression *bindings;
	struct expression *cond;
	struct expression *afterthought;
	struct expression *body;
};

struct expression_free {
	struct expression *expr;
};

struct expression_if {
	struct expression *cond;
	struct expression *true_branch, *false_branch;
};

struct match_case {
	const struct scope_object *object;	// NULL if not bound
	const struct type *type;		// NULL if default
	struct expression *value;
	struct match_case *next;
};

struct expression_match {
	struct expression *value;
	struct match_case *cases;
};

enum measure_operator {
	M_ALIGN,
	M_LEN,
	M_SIZE,
	M_OFFSET,
};

struct expression_measure {
	enum measure_operator op;
	union {
		struct expression *value;
		struct dimensions dimensions;
		// TODO: Field selection
	};
};

struct expression_return {
	struct expression *value;
};

struct expression_slice {
	struct expression *object;
	struct expression *start, *end;
	bool bounds_checked;
};

struct case_option {
	struct expression *value;
	struct case_option *next;
};

struct switch_case {
	struct case_option *options; // NULL for default case
	struct expression *value;
	struct switch_case *next;
};

struct expression_switch {
	struct expression *value;
	struct switch_case *cases;
};

struct expr_struct_field {
	const struct struct_field *field;
	struct expression *value;
	struct expr_struct_field *next;
};

struct expression_struct {
	struct expr_struct_field *fields;
	bool autofill;
};

struct expression_tuple {
	struct expression *value;
	struct expression_tuple *next;
};

enum unarithm_operator {
	UN_ADDRESS,	// &
	UN_BNOT,	// ~
	UN_DEREF,	// *
	UN_LNOT,	// !
	UN_MINUS,	// -
};

struct expression_unarithm {
	enum unarithm_operator op;
	struct expression *operand;
};

struct expression_vaarg {
	struct expression *ap;
};

struct expression {
	const struct type *result;
	enum expr_type type;
	struct location loc; // For fixed aborts
	union {
		struct expression_access access;
		struct expression_alloc alloc;
		struct expression_append append; // and insert
		struct expression_assert assert;
		struct expression_assign assign;
		struct expression_binarithm binarithm;
		struct expression_binding binding;
		struct expression_call call;
		struct expression_cast cast;
		struct expression_compound compound;
		struct expression_constant constant;
		struct expression_defer defer;
		struct expression_delete delete;
		struct expression_control control;
		struct expression_for _for;
		struct expression_free free;
		struct expression_if _if;
		struct expression_match match;
		struct expression_measure measure;
		struct expression_return _return;
		struct expression_switch _switch;
		struct expression_struct _struct;
		struct expression_slice slice;
		struct expression_tuple tuple;
		struct expression_unarithm unarithm;
		struct expression_vaarg vaarg;
		void *user;
	};
};

#endif
07070100000016000081A4000000000000000000000001654939DE00000A5F000000000000000000000000000000000000002700000000harec-1699297758.b4dd427/include/gen.h#ifndef HAREC_GEN_H
#define HAREC_GEN_H
#include <stddef.h>
#include "identifier.h"
#include "qbe.h"
#include "type_store.h"
#include "types.h"
#include "scope.h"

struct gen_arch {
	const struct qbe_type *ptr;
	const struct qbe_type *sz;
};

enum gen_value_kind {
	GV_CONST,
	GV_GLOBAL,
	GV_TEMP,
};

struct gen_value {
	enum gen_value_kind kind;
	bool threadlocal;
	const struct type *type;
	union {
		char *name;
		uint32_t wval;
		uint64_t lval;
		float sval;
		double dval;
	};
};

struct gen_binding {
	const struct scope_object *object;
	struct gen_value value;
	struct gen_binding *next;
};

struct gen_defer {
	const struct expression *expr;
	struct gen_defer *next;
};

struct gen_scope {
	const char *label;
	const struct scope *scope;
	struct gen_value result;
	struct gen_value *out;
	struct qbe_value *after;
	struct qbe_value *end;
	struct gen_defer *defers;
	struct gen_scope *parent;
};

struct rt {
	struct qbe_value abort, ensure, fixedabort, free, malloc,
			 memcpy, memmove, memset, strcmp, unensure;
};

struct gen_context {
	struct qbe_program *out;
	struct gen_arch arch;
	struct type_store *store;
	struct identifier *ns;
	struct rt rt;
	struct gen_value *sources;

int id;

struct qbe_func *current;
	const struct type *functype;
	struct gen_binding *bindings;
	struct gen_scope *scope;
};

struct unit;

void gen(const struct unit *unit,
		struct type_store *store,
		struct qbe_program *out);

// genutil.c
void rtfunc_init(struct gen_context *ctx);
struct gen_value mkgtemp(struct gen_context *ctx,
	const struct type *type, const char *fmt);
struct qbe_value mkqval(struct gen_context *ctx, const struct gen_value *value);
struct qbe_value mklval(struct gen_context *ctx, const struct gen_value *value);
struct qbe_value mkcopy(struct gen_context *ctx,
	const struct gen_value *value, const char *fmt);
struct qbe_value mkqtmp(struct gen_context *ctx,
	const struct qbe_type *qtype, const char *fmt);
struct qbe_value mklabel(struct gen_context *ctx,
	struct qbe_statement *stmt, const char *fmt);
void branch_copyresult(struct gen_context *ctx, struct gen_value result,
	struct gen_value merged, struct gen_value *out);

// qinstr.c
enum qbe_instr alloc_for_align(size_t align);
enum qbe_instr store_for_type(struct gen_context *ctx, const struct type *type);
enum qbe_instr load_for_type(struct gen_context *ctx, const struct type *type);
enum qbe_instr binarithm_for_op(struct gen_context *ctx,
	enum binarithm_operator op, const struct type *type);

// qtype.c
const struct qbe_type *qtype_lookup(struct gen_context *ctx,
	const struct type *type, bool xtype);
bool type_is_aggregate(const struct type *type);

#endif
07070100000017000081A4000000000000000000000001654939DE00000419000000000000000000000000000000000000002E00000000harec-1699297758.b4dd427/include/identifier.h#ifndef HARE_IDENTIFIER_H
#define HARE_IDENTIFIER_H
#include <stddef.h>
#include <stdbool.h>
#include <stdint.h>

// Maximum length of an identifier, as the sum of the lengths (excluding NUL
// terminators) of its parts plus one for each namespace deliniation.
//
// In other words, the length of "a::b::c" is 5.
#define IDENT_MAX 255

// Minimum buffer size needed to store an unparsed identifier, including the
// terminating NUL byte.
#define IDENT_BUFSIZ (IDENT_MAX / 2 + IDENT_MAX + 1)

struct identifier {
	char *name;
	struct identifier *ns;
};

struct identifiers {
	struct identifier ident;
	struct identifiers *next;
};

uint32_t identifier_hash(uint32_t init, const struct identifier *ident);
char *identifier_unparse(const struct identifier *ident);
int identifier_unparse_static(const struct identifier *ident, char *buf);
char *ident_to_sym(const struct identifier *ident);
void identifier_dup(struct identifier *new, const struct identifier *ident);
bool identifier_eq(const struct identifier *a, const struct identifier *b);

#endif
07070100000018000081A4000000000000000000000001654939DE00000959000000000000000000000000000000000000002700000000harec-1699297758.b4dd427/include/lex.h#ifndef HAREC_LEX_H
#define HAREC_LEX_H
#include <stdint.h>
#include <stdio.h>
#include "types.h"
#include "utf8.h"

#define C_EOF UTF8_INVALID

// Keep sorted
enum lexical_token {
	T_ATTR_FINI,
	T_ATTR_INIT,
	T_ATTR_OFFSET,
	T_ATTR_PACKED,
	T_ATTR_SYMBOL,
	T_ATTR_TEST,
	T_ATTR_THREADLOCAL,
	T_UNDERSCORE,
	T_ABORT,
	T_ALIGN,
	T_ALLOC,
	T_APPEND,
	T_AS,
	T_ASSERT,
	T_BOOL,
	T_BREAK,
	T_CASE,
	T_CONST,
	T_CONTINUE,
	T_DEF,
	T_DEFER,
	T_DELETE,
	T_ELSE,
	T_ENUM,
	T_EXPORT,
	T_F32,
	T_F64,
	T_FALSE,
	T_FN,
	T_FOR,
	T_FREE,
	T_I16,
	T_I32,
	T_I64,
	T_I8,
	T_IF,
	T_INSERT,
	T_INT,
	T_IS,
	T_LEN,
	T_LET,
	T_MATCH,
	T_NEVER,
	T_NULL,
	T_NULLABLE,
	T_OFFSET,
	T_OPAQUE,
	T_RETURN,
	T_RUNE,
	T_SIZE,
	T_STATIC,
	T_STR,
	T_STRUCT,
	T_SWITCH,
	T_TRUE,
	T_TYPE,
	T_U16,
	T_U32,
	T_U64,
	T_U8,
	T_UINT,
	T_UINTPTR,
	T_UNION,
	T_USE,
	T_VAARG,
	T_VAEND,
	T_VALIST,
	T_VASTART,
	T_VOID,
	T_YIELD,
	T_LAST_KEYWORD = T_YIELD,

// Operators
	T_ARROW,
	T_BANDEQ,
	T_BAND,
	T_BNOT,
	T_BOR,
	T_COLON,
	T_COMMA,
	T_DIV,
	T_DIVEQ,
	T_DOT,
	T_DOUBLE_COLON,
	T_ELLIPSIS,
	T_EQUAL,
	T_GREATER,
	T_GREATEREQ,
	T_LAND,
	T_LANDEQ,
	T_LBRACE,
	T_LBRACKET,
	T_LEQUAL,
	T_LESS,
	T_LESSEQ,
	T_LNOT,
	T_LOR,
	T_LOREQ,
	T_LPAREN,
	T_LSHIFT,
	T_LSHIFTEQ,
	T_LXOR,
	T_LXOREQ,
	T_MINUS,
	T_MINUSEQ,
	T_MODEQ,
	T_MODULO,
	T_NEQUAL,
	T_BOREQ,
	T_PLUS,
	T_PLUSEQ,
	T_QUESTION,
	T_RBRACE,
	T_RBRACKET,
	T_RPAREN,
	T_RSHIFT,
	T_RSHIFTEQ,
	T_SEMICOLON,
	T_SLICE,
	T_TIMES,
	T_TIMESEQ,
	T_BXOR,
	T_BXOREQ,
	T_LAST_OPERATOR = T_BXOREQ,

// Tokens with additional information
	T_LITERAL,
	T_NAME,

// Magic tokens
	T_EOF,
	T_NONE,
};

struct location {
	int file;
	int lineno, colno;
};

struct token {
	struct location loc;
	enum lexical_token token;
	enum type_storage storage;
	union {
		char *name;
		uint32_t rune;
		int64_t ival;
		uint64_t uval;
		double fval;
		struct {
			size_t len;
			char *value;
		} string;
	};
};

struct lexer {
	FILE *in;
	char *buf;
	size_t bufsz, buflen;
	uint32_t c[2];
	struct token un;
	struct location loc;
	bool require_int;
};

void lex_init(struct lexer *lexer, FILE *f, int fileid);
void lex_finish(struct lexer *lexer);
enum lexical_token lex(struct lexer *lexer, struct token *out);
void unlex(struct lexer *lexer, struct token *in);

void token_finish(struct token *tok);
const char *token_str(const struct token *tok);
const char *lexical_token_str(enum lexical_token tok);

#endif
07070100000019000081A4000000000000000000000001654939DE00000136000000000000000000000000000000000000002700000000harec-1699297758.b4dd427/include/mod.h#ifndef HARE_MOD_H
#define HARE_MOD_H
#include "identifier.h"
#include "scope.h"
#include "type_store.h"

struct modcache;
struct ast_global_decl;
struct context;
struct scope *module_resolve(struct context *ctx,
	struct ast_global_decl *defines,
	struct identifier *ident,
	struct type_store *store);

#endif
0707010000001A000081A4000000000000000000000001654939DE00000193000000000000000000000000000000000000002900000000harec-1699297758.b4dd427/include/parse.h#ifndef HAREC_PARSE_H
#define HAREC_PARSE_H
#include <stdio.h>

struct ast_expression;
struct ast_subunit;
struct ast_type;
struct lexer;

void parse(struct lexer *lexer, struct ast_subunit *unit);
bool parse_identifier(struct lexer *lexer, struct identifier *ident, bool trailing);
struct ast_type *parse_type(struct lexer *lexer);
struct ast_expression *parse_expression(struct lexer *lexer);

#endif
0707010000001B000081A4000000000000000000000001654939DE00000F26000000000000000000000000000000000000002700000000harec-1699297758.b4dd427/include/qbe.h#ifndef HAREC_QBE_H
#define HAREC_QBE_H
#include <stdarg.h>
#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>

enum qbe_stype {
	Q__VOID = 'V',
	Q_BYTE = 'b',
	Q_HALF = 'h',
	Q_WORD = 'w',
	Q_LONG = 'l',
	Q_SINGLE = 's',
	Q_DOUBLE = 'd',
	Q__AGGREGATE = 'A',
};

struct qbe_type;

struct qbe_field {
	const struct qbe_type *type;
	size_t count;
	struct qbe_field *next;
};

struct qbe_type {
	enum qbe_stype stype;
	size_t size;

// Aggregate types only:
	char *name;
	struct qbe_field fields;
	const struct type *base;
};

// Simple type singletons
extern const struct qbe_type
	qbe_byte,
	qbe_half,
	qbe_word,
	qbe_long,
	qbe_single,
	qbe_double,
	qbe_void,
	qbe_aggregate;

enum qbe_value_kind {
	QV_CONST,
	QV_GLOBAL,
	QV_LABEL,
	QV_TEMPORARY,
	QV_VARIADIC,
};

struct qbe_value {
	enum qbe_value_kind kind;
	bool threadlocal;
	const struct qbe_type *type;
	union {
		char *name;
		uint32_t wval;
		uint64_t lval;
		float sval;
		double dval;
	};
};

enum qbe_instr {
	Q_ADD,
	Q_ALLOC16,
	Q_ALLOC4,
	Q_ALLOC8,
	Q_AND,
	Q_BLIT,
	Q_CALL,
	Q_CAST,
	Q_CEQD,
	Q_CEQL,
	Q_CEQS,
	Q_CEQW,
	Q_CGED,
	Q_CGES,
	Q_CGTD,
	Q_CGTS,
	Q_CLED,
	Q_CLES,
	Q_CLTD,
	Q_CLTS,
	Q_CNED,
	Q_CNEL,
	Q_CNES,
	Q_CNEW,
	Q_COD,
	Q_COPY,
	Q_COS,
	Q_CSGEL,
	Q_CSGEW,
	Q_CSGTL,
	Q_CSGTW,
	Q_CSLEL,
	Q_CSLEW,
	Q_CSLTL,
	Q_CSLTW,
	Q_CUGEL,
	Q_CUGEW,
	Q_CUGTL,
	Q_CUGTW,
	Q_CULEL,
	Q_CULEW,
	Q_CULTL,
	Q_CULTW,
	Q_CUOD,
	Q_CUOS,
	Q_DBGLOC,
	Q_DIV,
	Q_DTOSI,
	Q_DTOUI,
	Q_EXTS,
	Q_EXTSB,
	Q_EXTSH,
	Q_EXTSW,
	Q_EXTUB,
	Q_EXTUH,
	Q_EXTUW,
	Q_HLT,
	Q_JMP,
	Q_JNZ,
	Q_LOADD,
	Q_LOADL,
	Q_LOADS,
	Q_LOADSB,
	Q_LOADSH,
	Q_LOADSW,
	Q_LOADUB,
	Q_LOADUH,
	Q_LOADUW,
	Q_MUL,
	Q_OR,
	Q_REM,
	Q_RET,
	Q_NEG,
	Q_SAR,
	Q_SHL,
	Q_SHR,
	Q_SLTOF,
	Q_STOREB,
	Q_STORED,
	Q_STOREH,
	Q_STOREL,
	Q_STORES,
	Q_STOREW,
	Q_STOSI,
	Q_STOUI,
	Q_SUB,
	Q_SWTOF,
	Q_TRUNCD,
	Q_UDIV,
	Q_ULTOF,
	Q_UREM,
	Q_UWTOF,
	Q_VAARG,
	Q_VASTART,
	Q_XOR,

Q_LAST_INSTR,
};

extern const char *qbe_instr[Q_LAST_INSTR];

enum qbe_statement_type {
	Q_COMMENT,
	Q_INSTR,
	Q_LABEL,
};

struct qbe_arguments {
	struct qbe_value value;
	struct qbe_arguments *next;
};

struct qbe_statement {
	enum qbe_statement_type type;
	union {
		struct {
			enum qbe_instr instr;
			struct qbe_value *out;
			struct qbe_arguments *args;
		};
		char *label;
		char *comment;
	};
};

struct qbe_func_param {
	char *name;
	const struct qbe_type *type;
	struct qbe_func_param *next;
};

struct qbe_statements {
	size_t ln, sz;
	struct qbe_statement *stmts;
};

struct qbe_func {
	const struct qbe_type *returns;
	struct qbe_func_param *params;
	bool variadic;
	struct qbe_statements prelude, body;
};

enum qbe_datatype {
	QD_ZEROED,
	QD_VALUE,
	QD_STRING,
	QD_SYMOFFS,
};

struct qbe_data_item {
	enum qbe_datatype type;
	union {
		struct qbe_value value;
		size_t zeroed;
		struct {
			char *str;
			size_t sz;
		};
		struct {
			char *sym;
			int64_t offset;
		};
	};
	struct qbe_data_item *next;
};

struct qbe_data {
	size_t align;
	char *section, *secflags;
	bool threadlocal;
	struct qbe_data_item items;
};

enum qbe_defkind {
	Q_TYPE,
	Q_FUNC,
	Q_DATA,
};

struct qbe_def {
	char *name;
	int file;
	enum qbe_defkind kind;
	bool exported;
	union {
		struct qbe_func func;
		struct qbe_type type;
		struct qbe_data data;
	};
	struct qbe_def *next;
};

struct qbe_program {
	struct qbe_def *defs;
	struct qbe_def **next;
};

void qbe_append_def(struct qbe_program *prog, struct qbe_def *def);

void pushi(struct qbe_func *func, const struct qbe_value *out, enum qbe_instr instr, ...);
void pushprei(struct qbe_func *func, const struct qbe_value *out, enum qbe_instr instr, ...);
void pushc(struct qbe_func *func, const char *fmt, ...);
void push(struct qbe_statements *stmts, struct qbe_statement *stmt);

struct qbe_value constl(uint64_t l);
struct qbe_value constw(uint32_t w);
struct qbe_value consts(float s);
struct qbe_value constd(double d);

#endif
0707010000001C000081A4000000000000000000000001654939DE000008AE000000000000000000000000000000000000002900000000harec-1699297758.b4dd427/include/scope.h#ifndef HAREC_SCOPE_H
#define HAREC_SCOPE_H
#include "expr.h"
#include "identifier.h"

#define SCOPE_BUCKETS 4096

enum object_type {
	O_BIND,
	O_CONST,
	O_DECL,
	O_SCAN,
	O_TYPE,
};

struct scope_object {
	enum object_type otype;
	// name is the name of the object within this scope (for lookups)
	// ident is the global identifier (these may be different in some cases)
	struct identifier name, ident;
	bool threadlocal;

const struct type *type;
	struct expression *value; // For O_CONST

struct scope_object *lnext; // Linked list
	struct scope_object *mnext; // Hash map
};

enum scope_class {
	SCOPE_COMPOUND,
	SCOPE_DEFER,
	SCOPE_ENUM,
	SCOPE_FUNC,
	SCOPE_LOOP,
	SCOPE_MATCH,
	SCOPE_SUBUNIT,
	SCOPE_UNIT,
	SCOPE_DEFINES,
};

struct yield {
	struct expression **expression;
	struct yield *next;
};

struct scope {
	enum scope_class class;
	const char *label;
	struct scope *parent;

const struct type *hint;
	struct type_tagged_union *results;
	struct yield *yields;

// Linked list in insertion order
	// Used for function parameters and enum values, where order matters
	struct scope_object *objects;
	struct scope_object **next;

// Hash map in reverse insertion order
	// Used for lookups, and accounts for shadowing
	struct scope_object *buckets[SCOPE_BUCKETS];
};

struct scopes {
	struct scope *scope;
	struct scopes *next;
};

struct scope *scope_push(struct scope **stack, enum scope_class class);
struct scope *scope_pop(struct scope **stack);

struct scope *scope_lookup_ancestor(struct scope *scope,
		enum scope_class class, const char *label);

void scope_free(struct scope *scope);
void scope_free_all(struct scopes *scopes);

void scope_object_init(struct scope_object *obj, enum object_type otype,
	const struct identifier *ident, const struct identifier *name,
	const struct type *type, struct expression *value);

void scope_insert_from_object(struct scope *scope, struct scope_object *object);

struct scope_object *scope_insert(
	struct scope *scope, enum object_type otype,
	const struct identifier *ident, const struct identifier *name,
	const struct type *type, struct expression *value);

struct scope_object *scope_lookup(struct scope *scope,
	const struct identifier *ident);

#endif
0707010000001D000081A4000000000000000000000001654939DE00000901000000000000000000000000000000000000002E00000000harec-1699297758.b4dd427/include/type_store.h#ifndef HARE_TYPESTORE_H
#define HARE_TYPESTORE_H
#include "ast.h"
#include "lex.h"
#include "types.h"

#define TYPE_STORE_BUCKETS 65536

struct type_bucket {
	struct type type;
	struct type_bucket *next;
};

struct context;

struct type_store {
	struct type_bucket *buckets[TYPE_STORE_BUCKETS];
	struct context *check_context;
};

// Applies the type reduction algorithm to the given tagged union.
const struct type *type_store_reduce_result(struct type_store *store,
		struct location loc, struct type_tagged_union *in);

struct ast_type;

const struct type *type_store_lookup_atype(
	struct type_store *store, const struct ast_type *atype);

struct dimensions type_store_lookup_dimensions(
	struct type_store *store, const struct ast_type *atype);

const struct type *builtin_type_for_storage(
	enum type_storage storage, bool is_const);

const struct type *type_store_lookup_with_flags(struct type_store *store,
	const struct type *type, unsigned int flags);

const struct type *type_store_lookup_pointer(struct type_store *store,
	struct location loc, const struct type *referent, unsigned int ptrflags);

const struct type *type_store_lookup_array(struct type_store *store,
	struct location loc, const struct type *members, size_t len,
	bool expandable);

const struct type *type_store_lookup_slice(struct type_store *store,
	struct location loc, const struct type *members);

// Looks up a type alias, which may be incomplete. If the dimensions of the
// type are known, provide them as a hint in the dims argument (which can be
// NULL otherwise). This is used as a hint to skip adding padding to packed
// struct types.
const struct type *type_store_lookup_alias(struct type_store *store,
	const struct type *secondary, const struct dimensions *dims);

const struct type *type_store_lookup_tagged(struct type_store *store,
	struct location loc, struct type_tagged_union *tags);

// Returns a (non-tagged) union of the members of a tagged union type
const struct type *type_store_tagged_to_union(
	struct type_store *store, const struct type *tagged);

const struct type *type_store_lookup_tuple(struct type_store *store,
	 struct location loc, struct type_tuple *values);

const struct type *type_store_lookup_enum(struct type_store *store,
	const struct ast_type *atype, bool exported);

#endif
0707010000001E000081A4000000000000000000000001654939DE000000CB000000000000000000000000000000000000002B00000000harec-1699297758.b4dd427/include/typedef.h#ifndef HARE_TYPEDEF_H
#define HARE_TYPEDEF_H
#include <stdio.h>

struct type;
struct unit;

void emit_type(const struct type *type, FILE *out);
void emit_typedefs(struct unit *unit, FILE *out);

#endif
0707010000001F000081A4000000000000000000000001654939DE000016A5000000000000000000000000000000000000002900000000harec-1699297758.b4dd427/include/types.h#ifndef HARE_TYPES_H
#define HARE_TYPES_H
#include <stdbool.h>
#include <stdint.h>
#include "identifier.h"

enum type_storage {
	// Built-in types
	// The order of these is important
	STORAGE_BOOL,
	STORAGE_F32,
	STORAGE_F64,
	STORAGE_I16,
	STORAGE_I32,
	STORAGE_I64,
	STORAGE_I8,
	STORAGE_INT,
	STORAGE_NEVER,
	STORAGE_NULL,
	STORAGE_OPAQUE,
	STORAGE_RUNE,
	STORAGE_SIZE,
	STORAGE_STRING,
	STORAGE_U16,
	STORAGE_U32,
	STORAGE_U64,
	STORAGE_U8,
	STORAGE_UINT,
	STORAGE_UINTPTR,
	STORAGE_VOID,
	// Other types
	STORAGE_ALIAS,
	STORAGE_ARRAY,
	STORAGE_ENUM,
	STORAGE_FUNCTION,
	STORAGE_POINTER,
	STORAGE_SLICE,
	STORAGE_STRUCT,
	STORAGE_TAGGED,
	STORAGE_TUPLE,
	STORAGE_UNION,
	STORAGE_VALIST,
	STORAGE_FCONST,
	STORAGE_ICONST,
	STORAGE_RCONST,
	// For internal use only
	STORAGE_ERROR,
};

struct context;
struct type;

#define SIZE_UNDEFINED ((size_t)-1)
#define ALIGN_UNDEFINED ((size_t)-1)

struct type_alias {
	struct identifier ident;
	struct identifier name;
	const struct type *type;
	bool exported; // Used to make sure unexported aliases aren't emitted
};

struct type_array {
	size_t length; // SIZE_UNDEFINED for [*] and slices
	const struct type *members;
	bool expandable;
};

struct type_enum {
	struct scope *values;
};

enum variadism {
	VARIADISM_NONE,
	VARIADISM_C,
	VARIADISM_HARE,
};

struct type_func_param {
	const struct type *type;
	struct type_func_param *next;
};

struct type_func {
	const struct type *result;
	enum variadism variadism;
	struct type_func_param *params;
};

struct type_const {
	int64_t min, max;
	uint32_t id;
	const struct type ***refs;
	size_t nrefs;
	size_t zrefs;
};

enum pointer_flags {
	PTR_NULLABLE = 1 << 0,
};

struct type_pointer {
	const struct type *referent;
	unsigned int flags;
};

struct struct_field {
	char *name;
	const struct type *type;
	size_t offset;
	size_t size;
	struct struct_field *next;
};

struct type_struct_union {
	struct struct_field *fields;
	// c_compat is false if explicit offsets are used, or if the type is a
	// union. The latter is actually still C-compatible, but this is an
	// implementation detail which changes the way the QBE IL is generated,
	// and in the case of unions, the altered behavior for explicit-offset
	// structs is also correct for all cases of unions.
	bool c_compat;
	bool packed;
};

struct type_tuple {
	const struct type *type;
	size_t offset;
	struct type_tuple *next;
};

struct type_tagged_union {
	const struct type *type;
	struct type_tagged_union *next;
};

enum type_flags {
	TYPE_CONST = 1 << 0,
	TYPE_ERROR = 1 << 1,
};

struct type {
	enum type_storage storage;
	uint32_t id;
	unsigned int flags;
	size_t size, align;
	union {
		struct {
			struct type_alias alias;
			struct type_enum _enum;
		};
		struct type_array array;
		struct type_func func;
		struct type_const _const;
		struct type_pointer pointer;
		struct type_struct_union struct_union;
		struct type_tagged_union tagged;
		struct type_tuple tuple;
	};
};

struct dimensions {
	size_t size;
	size_t align;
};

const struct type *type_dereference(struct context *ctx, const struct type *type);
const struct type *type_dealias(struct context *ctx, const struct type *type);
const struct struct_field *type_get_field(struct context *ctx,
	const struct type *type, const char *name);
const struct type_tuple *type_get_value(
	const struct type *type, uint64_t index);

const struct type *tagged_select_subtype(struct context *ctx,
	const struct type *tagged, const struct type *subtype, bool strip);
bool tagged_subset_compat(struct context *ctx,
	const struct type *to, const struct type *from);

const char *type_storage_unparse(enum type_storage storage);
bool type_is_signed(struct context *ctx, const struct type *type);
bool type_is_integer(struct context *ctx, const struct type *type);
bool type_is_numeric(struct context *ctx, const struct type *type);
bool type_is_float(struct context *ctx, const struct type *type);
bool type_is_constant(const struct type *type);
bool type_has_error(struct context *ctx, const struct type *type);

uint32_t type_hash(const struct type *type);

const struct type *promote_const(struct context *ctx,
	const struct type *a, const struct type *b);
bool type_is_assignable(struct context *ctx,
	const struct type *to, const struct type *from);
const struct type *type_is_castable(struct context *ctx,
	const struct type *to, const struct type *from);

const struct type *type_create_const(enum type_storage storage,
	int64_t min, int64_t max);
const struct type *lower_const(struct context *ctx,
	const struct type *old, const struct type *new);
void const_refer(const struct type *type, const struct type **ref);
void const_reset_refs(const struct type *type);

void builtin_types_init(const char *target);

// Built-in type singletons
extern struct type
	// Primitive
	builtin_type_bool,
	builtin_type_error,
	builtin_type_f32,
	builtin_type_f64,
	builtin_type_i8,
	builtin_type_i16,
	builtin_type_i32,
	builtin_type_i64,
	builtin_type_int,
	builtin_type_never,
	builtin_type_opaque,
	builtin_type_u8,
	builtin_type_u16,
	builtin_type_u32,
	builtin_type_u64,
	builtin_type_uint,
	builtin_type_uintptr,
	builtin_type_null,
	builtin_type_rune,
	builtin_type_size,
	builtin_type_void,
	// Const primitives
	builtin_type_const_bool,
	builtin_type_const_f32,
	builtin_type_const_f64,
	builtin_type_const_i8,
	builtin_type_const_i16,
	builtin_type_const_i32,
	builtin_type_const_i64,
	builtin_type_const_int,
	builtin_type_const_never,
	builtin_type_const_opaque,
	builtin_type_const_u8,
	builtin_type_const_u16,
	builtin_type_const_u32,
	builtin_type_const_u64,
	builtin_type_const_uint,
	builtin_type_const_uintptr,
	builtin_type_const_rune,
	builtin_type_const_size,
	builtin_type_const_void,
	// etc
	builtin_type_str,
	builtin_type_const_str,
	builtin_type_valist;

#endif
07070100000020000081A4000000000000000000000001654939DE000001E1000000000000000000000000000000000000002800000000harec-1699297758.b4dd427/include/utf8.h#ifndef HAREC_UTF8_H
#define HAREC_UTF8_H
#include <limits.h>
#include <stdio.h>

#define UTF8_MAX_SIZE 4

#define UTF8_INVALID UINT32_MAX

/**
 * Grabs the next UTF-8 codepoint and advances the string pointer
 */
uint32_t utf8_decode(const char **str);

/**
 * Encodes a codepoint as UTF-8 and returns the length of that codepoint.
 */
size_t utf8_encode(char *str, uint32_t ch);

/**
 * Reads and returns the next codepoint from the file.
 */
uint32_t utf8_get(FILE *f);

#endif
07070100000021000081A4000000000000000000000001654939DE00000460000000000000000000000000000000000000002800000000harec-1699297758.b4dd427/include/util.h#ifndef HARE_UTIL_H
#define HARE_UTIL_H
#include <assert.h>
#include <stdarg.h>
#include <stdint.h>
#include <stdio.h>
#include "lex.h"

extern const char **sources;
extern size_t nsources;

#define FNV1A_INIT 2166136261u

uint32_t fnv1a(uint32_t hash, unsigned char c);
uint32_t fnv1a_u32(uint32_t hash, uint32_t u32);
uint32_t fnv1a_size(uint32_t hash, size_t sz);
uint32_t fnv1a_s(uint32_t hash, const char *str);
int xfprintf(FILE *restrict f, const char *restrict fmt, ...);
int xvfprintf(FILE *restrict f, const char *restrict fmt, va_list ap);
void *xcalloc(size_t n, size_t s);
void *xrealloc(void *p, size_t s);
char *xstrdup(const char *s);

#define malloc(a) (void *)sizeof(struct { static_assert(0, "Use xcalloc instead"); int _; })
#define calloc(a, b) (void *)sizeof(struct { static_assert(0, "Use xcalloc instead"); int _; })
#define realloc(a, b) (void *)sizeof(struct { static_assert(0, "Use xrealloc instead"); int _; })
#define strdup(s) (char *)(sizeof(struct { static_assert(0, "Use xstrdup instead"); int _; })

char *gen_name(int *id, const char *fmt);

void errline(struct location loc);

#endif
07070100000022000041ED000000000000000000000002654939DE00000000000000000000000000000000000000000000001C00000000harec-1699297758.b4dd427/rt07070100000023000041ED000000000000000000000002654939DE00000000000000000000000000000000000000000000002500000000harec-1699297758.b4dd427/rt/+freebsd07070100000024000081A4000000000000000000000001654939DE00000BFA000000000000000000000000000000000000002E00000000harec-1699297758.b4dd427/rt/+freebsd/errno.haexport def EPERM: int = 1;
export def ENOENT: int = 2;
export def ESRCH: int = 3;
export def EINTR: int = 4;
export def EIO: int = 5;
export def ENXIO: int = 6;
export def E2BIG: int = 7;
export def ENOEXEC: int = 8;
export def EBADF: int = 9;
export def ECHILD: int = 10;
export def EDEADLK: int = 11;
export def ENOMEM: int = 12;
export def EACCES: int = 13;
export def EFAULT: int = 14;
export def ENOTBLK: int = 15;
export def EBUSY: int = 16;
export def EEXIST: int = 17;
export def EXDEV: int = 18;
export def ENODEV: int = 19;
export def ENOTDIR: int = 20;
export def EISDIR: int = 21;
export def EINVAL: int = 22;
export def ENFILE: int = 23;
export def EMFILE: int = 24;
export def ENOTTY: int = 25;
export def ETXTBSY: int = 26;
export def EFBIG: int = 27;
export def ENOSPC: int = 28;
export def ESPIPE: int = 29;
export def EROFS: int = 30;
export def EMLINK: int = 31;
export def EPIPE: int = 32;
export def EDOM: int = 33;
export def ERANGE: int = 34;
export def EAGAIN: int = 35;
export def EWOULDBLOCK: int = EAGAIN;
export def EINPROGRESS: int = 36;
export def EALREADY: int = 37;
export def ENOTSOCK: int = 38;
export def EDESTADDRREQ: int = 39;
export def EMSGSIZE: int = 40;
export def EPROTOTYPE: int = 41;
export def ENOPROTOOPT: int = 42;
export def EPROTONOSUPPORT: int = 43;
export def ESOCKTNOSUPPORT: int = 44;
export def EOPNOTSUPP: int = 45;
export def ENOTSUP: int = EOPNOTSUPP;
export def EPFNOSUPPORT: int = 46;
export def EAFNOSUPPORT: int = 47;
export def EADDRINUSE: int = 48;
export def EADDRNOTAVAIL: int = 49;
export def ENETDOWN: int = 50;
export def ENETUNREACH: int = 51;
export def ENETRESET: int = 52;
export def ECONNABORTED: int = 53;
export def ECONNRESET: int = 54;
export def ENOBUFS: int = 55;
export def EISCONN: int = 56;
export def ENOTCONN: int = 57;
export def ESHUTDOWN: int = 58;
export def ETOOMANYREFS: int = 59;
export def ETIMEDOUT: int = 60;
export def ECONNREFUSED: int = 61;
export def ELOOP: int = 62;
export def ENAMETOOLONG: int = 63;
export def EHOSTDOWN: int = 64;
export def EHOSTUNREACH: int = 65;
export def ENOTEMPTY: int = 66;
export def EPROCLIM: int = 67;
export def EUSERS: int = 68;
export def EDQUOT: int = 69;
export def ESTALE: int = 70;
export def EREMOTE: int = 71;
export def EBADRPC: int = 72;
export def ERPCMISMATCH: int = 73;
export def EPROGUNAVAIL: int = 74;
export def EPROGMISMATCH: int = 75;
export def EPROCUNAVAIL: int = 76;
export def ENOLCK: int = 77;
export def ENOSYS: int = 78;
export def EFTYPE: int = 79;
export def EAUTH: int = 80;
export def ENEEDAUTH: int = 81;
export def EIDRM: int = 82;
export def ENOMSG: int = 83;
export def EOVERFLOW: int = 84;
export def ECANCELED: int = 85;
export def EILSEQ: int = 86;
export def ENOATTR: int = 87;
export def EDOOFUS: int = 88;
export def EBADMSG: int = 89;
export def EMULTIHOP: int = 90;
export def ENOLINK: int = 91;
export def EPROTO: int = 92;
export def ENOTCAPABLE: int = 93;
export def ECAPMODE: int = 94;
export def ENOTRECOVERABLE: int = 95;
export def EOWNERDEAD: int = 96;
export def EINTEGRITY: int = 97;
07070100000025000081A4000000000000000000000001654939DE00000139000000000000000000000000000000000000003200000000harec-1699297758.b4dd427/rt/+freebsd/segmalloc.ha// Allocates a segment.
fn segmalloc(n: size) nullable *opaque = {
	let p: *opaque = mmap(null, n,
		PROT_READ | PROT_WRITE,
		MAP_PRIVATE | MAP_ANON, -1, 0);
	return if (p: uintptr: int == -ENOMEM) null else p;
};

// Frees a segment allocated with segmalloc.
fn segfree(p: *opaque, s: size) int = munmap(p, s);
07070100000026000081A4000000000000000000000001654939DE00000058000000000000000000000000000000000000003500000000harec-1699297758.b4dd427/rt/+freebsd/start+aarch64.s.text
.global _start
_start:
	mov x29, #0
	mov x30, #0
	and sp, sp, #-16
	b rt.start_ha
07070100000027000081A4000000000000000000000001654939DE00000041000000000000000000000000000000000000003500000000harec-1699297758.b4dd427/rt/+freebsd/start+riscv64.s.text
.global _start
_start:
	andi sp, sp, -16
	tail rt.start_ha
07070100000028000081A4000000000000000000000001654939DE00000050000000000000000000000000000000000000003400000000harec-1699297758.b4dd427/rt/+freebsd/start+x86_64.s.text
.global _start
_start:
	xor %rbp, %rbp
	andq $-16, %rsp
	call rt.start_ha
07070100000029000081A4000000000000000000000001654939DE0000034E000000000000000000000000000000000000003700000000harec-1699297758.b4dd427/rt/+freebsd/syscall+aarch64.s.section .text.rt.syscall0
.global rt.syscall0
rt.syscall0:
	mov x8, x0
	svc 0
	ret

.section .text.rt.syscall1
.global rt.syscall1
rt.syscall1:
	mov x8, x0
	mov x0, x1
	svc 0
	ret

.section .text.rt.syscall2
.global rt.syscall2
rt.syscall2:
	mov x8, x0
	mov x0, x1
	mov x1, x2
	svc 0
	ret

.section .text.rt.syscall3
.global rt.syscall3
rt.syscall3:
	mov x8, x0
	mov x0, x1
	mov x1, x2
	mov x2, x3
	svc 0
	ret

.section .text.rt.syscall4
.global rt.syscall4
rt.syscall4:
	mov x8, x0
	mov x0, x1
	mov x1, x2
	mov x2, x3
	mov x3, x4
	svc 0
	ret

.section .text.rt.syscall5
.global rt.syscall5
rt.syscall5:
	mov x8, x0
	mov x0, x1
	mov x1, x2
	mov x2, x3
	mov x3, x4
	mov x4, x5
	svc 0
	ret

.section .text.rt.syscall6
.global rt.syscall6
rt.syscall6:
	mov x8, x0
	mov x0, x1
	mov x1, x2
	mov x2, x3
	mov x3, x4
	mov x4, x5
	mov x5, x6
	svc 0
	ret
0707010000002A000081A4000000000000000000000001654939DE00000332000000000000000000000000000000000000003700000000harec-1699297758.b4dd427/rt/+freebsd/syscall+riscv64.s.section .text.rt.syscall0
.global rt.syscall0
rt.syscall0:
	mv a7, a0
	ecall
	ret

.section .text.rt.syscall1
.global rt.syscall1
rt.syscall1:
	mv a7, a0
	mv a0, a1
	ecall
	ret

.section .text.rt.syscall2
.global rt.syscall2
rt.syscall2:
	mv a7, a0
	mv a0, a1
	mv a1, a2
	ecall
	ret

.section .text.rt.syscall3
.global rt.syscall3
rt.syscall3:
	mv a7, a0
	mv a0, a1
	mv a1, a2
	mv a2, a3
	ecall
	ret

.section .text.rt.syscall4
.global rt.syscall4
rt.syscall4:
	mv a7, a0
	mv a0, a1
	mv a1, a2
	mv a2, a3
	mv a3, a4
	ecall
	ret

.section .text.rt.syscall5
.global rt.syscall5
rt.syscall5:
	mv a7, a0
	mv a0, a1
	mv a1, a2
	mv a2, a3
	mv a3, a4
	mv a4, a5
	ecall
	ret

.section .text.rt.syscall6
.global rt.syscall6
rt.syscall6:
	mv a7, a0
	mv a0, a1
	mv a1, a2
	mv a2, a3
	mv a3, a4
	mv a4, a5
	mv a5, a6
	ecall
	ret
0707010000002B000081A4000000000000000000000001654939DE000003E3000000000000000000000000000000000000003600000000harec-1699297758.b4dd427/rt/+freebsd/syscall+x86_64.s.section .text.rt.syscall0
.global rt.syscall0
rt.syscall0:
	movq %rdi, %rax
	syscall
	ret

.section .text.rt.syscall1
.global rt.syscall1
rt.syscall1:
	movq %rdi, %rax
	movq %rsi, %rdi
	syscall
	ret

.section .text.rt.syscall2
.global rt.syscall2
rt.syscall2:
	movq %rdi, %rax
	movq %rsi, %rdi
	movq %rdx, %rsi
	syscall
	ret

.section .text.rt.syscall3
.global rt.syscall3
rt.syscall3:
	movq %rdi, %rax
	movq %rsi, %rdi
	movq %rdx, %rsi
	movq %rcx, %rdx
	syscall
	ret

.section .text.rt.syscall4
.global rt.syscall4
rt.syscall4:
	movq %rdi, %rax
	movq %r8, %r10
	movq %rsi, %rdi
	movq %rdx, %rsi
	movq %rcx, %rdx
	syscall
	ret

.section .text.rt.syscall5
.global rt.syscall5
rt.syscall5:
	movq %rdi, %rax
	movq %r8, %r10
	movq %rsi, %rdi
	movq %r9, %r8
	movq %rdx, %rsi
	movq %rcx, %rdx
	syscall
	ret

.section .text.rt.syscall6
.global rt.syscall6
rt.syscall6:
	movq %rdi, %rax
	movq %r8, %r10
	movq %rsi, %rdi
	movq %r9, %r8
	movq %rdx, %rsi
	movq 8(%rsp), %r9
	movq %rcx, %rdx
	syscall
	ret
0707010000002C000081A4000000000000000000000001654939DE00003D7D000000000000000000000000000000000000003200000000harec-1699297758.b4dd427/rt/+freebsd/syscallno.haexport def SYS_syscall: u64 = 0;
export def SYS_exit: u64 = 1;
export def SYS_fork: u64 = 2;
export def SYS_read: u64 = 3;
export def SYS_write: u64 = 4;
export def SYS_open: u64 = 5;
export def SYS_close: u64 = 6;
export def SYS_wait4: u64 = 7;
export def SYS_link: u64 = 9;
export def SYS_unlink: u64 = 10;
export def SYS_chdir: u64 = 12;
export def SYS_fchdir: u64 = 13;
export def SYS_freebsd11_mknod: u64 = 14;
export def SYS_chmod: u64 = 15;
export def SYS_chown: u64 = 16;
export def SYS_break: u64 = 17;
export def SYS_getpid: u64 = 20;
export def SYS_mount: u64 = 21;
export def SYS_unmount: u64 = 22;
export def SYS_setuid: u64 = 23;
export def SYS_getuid: u64 = 24;
export def SYS_geteuid: u64 = 25;
export def SYS_ptrace: u64 = 26;
export def SYS_recvmsg: u64 = 27;
export def SYS_sendmsg: u64 = 28;
export def SYS_recvfrom: u64 = 29;
export def SYS_accept: u64 = 30;
export def SYS_getpeername: u64 = 31;
export def SYS_getsockname: u64 = 32;
export def SYS_access: u64 = 33;
export def SYS_chflags: u64 = 34;
export def SYS_fchflags: u64 = 35;
export def SYS_sync: u64 = 36;
export def SYS_kill: u64 = 37;
export def SYS_getppid: u64 = 39;
export def SYS_dup: u64 = 41;
export def SYS_freebsd10_pipe: u64 = 42;
export def SYS_getegid: u64 = 43;
export def SYS_profil: u64 = 44;
export def SYS_ktrace: u64 = 45;
export def SYS_getgid: u64 = 47;
export def SYS_getlogin: u64 = 49;
export def SYS_setlogin: u64 = 50;
export def SYS_acct: u64 = 51;
export def SYS_sigaltstack: u64 = 53;
export def SYS_ioctl: u64 = 54;
export def SYS_reboot: u64 = 55;
export def SYS_revoke: u64 = 56;
export def SYS_symlink: u64 = 57;
export def SYS_readlink: u64 = 58;
export def SYS_execve: u64 = 59;
export def SYS_umask: u64 = 60;
export def SYS_chroot: u64 = 61;
export def SYS_msync: u64 = 65;
export def SYS_vfork: u64 = 66;
export def SYS_sbrk: u64 = 69;
export def SYS_sstk: u64 = 70;
export def SYS_freebsd11_vadvise: u64 = 72;
export def SYS_munmap: u64 = 73;
export def SYS_mprotect: u64 = 74;
export def SYS_madvise: u64 = 75;
export def SYS_mincore: u64 = 78;
export def SYS_getgroups: u64 = 79;
export def SYS_setgroups: u64 = 80;
export def SYS_getpgrp: u64 = 81;
export def SYS_setpgid: u64 = 82;
export def SYS_setitimer: u64 = 83;
export def SYS_swapon: u64 = 85;
export def SYS_getitimer: u64 = 86;
export def SYS_getdtablesize: u64 = 89;
export def SYS_dup2: u64 = 90;
export def SYS_fcntl: u64 = 92;
export def SYS_select: u64 = 93;
export def SYS_fsync: u64 = 95;
export def SYS_setpriority: u64 = 96;
export def SYS_socket: u64 = 97;
export def SYS_connect: u64 = 98;
export def SYS_getpriority: u64 = 100;
export def SYS_bind: u64 = 104;
export def SYS_setsockopt: u64 = 105;
export def SYS_listen: u64 = 106;
export def SYS_gettimeofday: u64 = 116;
export def SYS_getrusage: u64 = 117;
export def SYS_getsockopt: u64 = 118;
export def SYS_readv: u64 = 120;
export def SYS_writev: u64 = 121;
export def SYS_settimeofday: u64 = 122;
export def SYS_fchown: u64 = 123;
export def SYS_fchmod: u64 = 124;
export def SYS_setreuid: u64 = 126;
export def SYS_setregid: u64 = 127;
export def SYS_rename: u64 = 128;
export def SYS_flock: u64 = 131;
export def SYS_mkfifo: u64 = 132;
export def SYS_sendto: u64 = 133;
export def SYS_shutdown: u64 = 134;
export def SYS_socketpair: u64 = 135;
export def SYS_mkdir: u64 = 136;
export def SYS_rmdir: u64 = 137;
export def SYS_utimes: u64 = 138;
export def SYS_adjtime: u64 = 140;
export def SYS_setsid: u64 = 147;
export def SYS_quotactl: u64 = 148;
export def SYS_nlm_syscall: u64 = 154;
export def SYS_nfssvc: u64 = 155;
export def SYS_lgetfh: u64 = 160;
export def SYS_getfh: u64 = 161;
export def SYS_sysarch: u64 = 165;
export def SYS_rtprio: u64 = 166;
export def SYS_semsys: u64 = 169;
export def SYS_msgsys: u64 = 170;
export def SYS_shmsys: u64 = 171;
export def SYS_setfib: u64 = 175;
export def SYS_ntp_adjtime: u64 = 176;
export def SYS_setgid: u64 = 181;
export def SYS_setegid: u64 = 182;
export def SYS_seteuid: u64 = 183;
export def SYS_freebsd11_stat: u64 = 188;
export def SYS_freebsd11_fstat: u64 = 189;
export def SYS_freebsd11_lstat: u64 = 190;
export def SYS_pathconf: u64 = 191;
export def SYS_fpathconf: u64 = 192;
export def SYS_getrlimit: u64 = 194;
export def SYS_setrlimit: u64 = 195;
export def SYS_freebsd11_getdirentries: u64 = 196;
export def SYS___syscall: u64 = 198;
export def SYS___sysctl: u64 = 202;
export def SYS_mlock: u64 = 203;
export def SYS_munlock: u64 = 204;
export def SYS_undelete: u64 = 205;
export def SYS_futimes: u64 = 206;
export def SYS_getpgid: u64 = 207;
export def SYS_poll: u64 = 209;
export def SYS_freebsd7___semctl: u64 = 220;
export def SYS_semget: u64 = 221;
export def SYS_semop: u64 = 222;
export def SYS_freebsd7_msgctl: u64 = 224;
export def SYS_msgget: u64 = 225;
export def SYS_msgsnd: u64 = 226;
export def SYS_msgrcv: u64 = 227;
export def SYS_shmat: u64 = 228;
export def SYS_freebsd7_shmctl: u64 = 229;
export def SYS_shmdt: u64 = 230;
export def SYS_shmget: u64 = 231;
export def SYS_clock_gettime: u64 = 232;
export def SYS_clock_settime: u64 = 233;
export def SYS_clock_getres: u64 = 234;
export def SYS_ktimer_create: u64 = 235;
export def SYS_ktimer_delete: u64 = 236;
export def SYS_ktimer_settime: u64 = 237;
export def SYS_ktimer_gettime: u64 = 238;
export def SYS_ktimer_getoverrun: u64 = 239;
export def SYS_nanosleep: u64 = 240;
export def SYS_ffclock_getcounter: u64 = 241;
export def SYS_ffclock_setestimate: u64 = 242;
export def SYS_ffclock_getestimate: u64 = 243;
export def SYS_clock_nanosleep: u64 = 244;
export def SYS_clock_getcpuclockid2: u64 = 247;
export def SYS_ntp_gettime: u64 = 248;
export def SYS_minherit: u64 = 250;
export def SYS_rfork: u64 = 251;
export def SYS_issetugid: u64 = 253;
export def SYS_lchown: u64 = 254;
export def SYS_aio_read: u64 = 255;
export def SYS_aio_write: u64 = 256;
export def SYS_lio_listio: u64 = 257;
export def SYS_freebsd11_getdents: u64 = 272;
export def SYS_lchmod: u64 = 274;
export def SYS_lutimes: u64 = 276;
export def SYS_freebsd11_nstat: u64 = 278;
export def SYS_freebsd11_nfstat: u64 = 279;
export def SYS_freebsd11_nlstat: u64 = 280;
export def SYS_preadv: u64 = 289;
export def SYS_pwritev: u64 = 290;
export def SYS_fhopen: u64 = 298;
export def SYS_freebsd11_fhstat: u64 = 299;
export def SYS_modnext: u64 = 300;
export def SYS_modstat: u64 = 301;
export def SYS_modfnext: u64 = 302;
export def SYS_modfind: u64 = 303;
export def SYS_kldload: u64 = 304;
export def SYS_kldunload: u64 = 305;
export def SYS_kldfind: u64 = 306;
export def SYS_kldnext: u64 = 307;
export def SYS_kldstat: u64 = 308;
export def SYS_kldfirstmod: u64 = 309;
export def SYS_getsid: u64 = 310;
export def SYS_setresuid: u64 = 311;
export def SYS_setresgid: u64 = 312;
export def SYS_aio_return: u64 = 314;
export def SYS_aio_suspend: u64 = 315;
export def SYS_aio_cancel: u64 = 316;
export def SYS_aio_error: u64 = 317;
export def SYS_yield: u64 = 321;
export def SYS_mlockall: u64 = 324;
export def SYS_munlockall: u64 = 325;
export def SYS___getcwd: u64 = 326;
export def SYS_sched_setparam: u64 = 327;
export def SYS_sched_getparam: u64 = 328;
export def SYS_sched_setscheduler: u64 = 329;
export def SYS_sched_getscheduler: u64 = 330;
export def SYS_sched_yield: u64 = 331;
export def SYS_sched_get_priority_max: u64 = 332;
export def SYS_sched_get_priority_min: u64 = 333;
export def SYS_sched_rr_get_u64erval: u64 = 334;
export def SYS_utrace: u64 = 335;
export def SYS_kldsym: u64 = 337;
export def SYS_jail: u64 = 338;
export def SYS_nnpfs_syscall: u64 = 339;
export def SYS_sigprocmask: u64 = 340;
export def SYS_sigsuspend: u64 = 341;
export def SYS_sigpending: u64 = 343;
export def SYS_sigtimedwait: u64 = 345;
export def SYS_sigwaitinfo: u64 = 346;
export def SYS___acl_get_file: u64 = 347;
export def SYS___acl_set_file: u64 = 348;
export def SYS___acl_get_fd: u64 = 349;
export def SYS___acl_set_fd: u64 = 350;
export def SYS___acl_delete_file: u64 = 351;
export def SYS___acl_delete_fd: u64 = 352;
export def SYS___acl_aclcheck_file: u64 = 353;
export def SYS___acl_aclcheck_fd: u64 = 354;
export def SYS_extattrctl: u64 = 355;
export def SYS_extattr_set_file: u64 = 356;
export def SYS_extattr_get_file: u64 = 357;
export def SYS_extattr_delete_file: u64 = 358;
export def SYS_aio_waitcomplete: u64 = 359;
export def SYS_getresuid: u64 = 360;
export def SYS_getresgid: u64 = 361;
export def SYS_kqueue: u64 = 362;
export def SYS_freebsd11_kevent: u64 = 363;
export def SYS_extattr_set_fd: u64 = 371;
export def SYS_extattr_get_fd: u64 = 372;
export def SYS_extattr_delete_fd: u64 = 373;
export def SYS___setugid: u64 = 374;
export def SYS_eaccess: u64 = 376;
export def SYS_afs3_syscall: u64 = 377;
export def SYS_nmount: u64 = 378;
export def SYS___mac_get_proc: u64 = 384;
export def SYS___mac_set_proc: u64 = 385;
export def SYS___mac_get_fd: u64 = 386;
export def SYS___mac_get_file: u64 = 387;
export def SYS___mac_set_fd: u64 = 388;
export def SYS___mac_set_file: u64 = 389;
export def SYS_kenv: u64 = 390;
export def SYS_lchflags: u64 = 391;
export def SYS_uuidgen: u64 = 392;
export def SYS_sendfile: u64 = 393;
export def SYS_mac_syscall: u64 = 394;
export def SYS_freebsd11_getfsstat: u64 = 395;
export def SYS_freebsd11_statfs: u64 = 396;
export def SYS_freebsd11_fstatfs: u64 = 397;
export def SYS_freebsd11_fhstatfs: u64 = 398;
export def SYS_ksem_close: u64 = 400;
export def SYS_ksem_post: u64 = 401;
export def SYS_ksem_wait: u64 = 402;
export def SYS_ksem_trywait: u64 = 403;
export def SYS_ksem_init: u64 = 404;
export def SYS_ksem_open: u64 = 405;
export def SYS_ksem_unlink: u64 = 406;
export def SYS_ksem_getvalue: u64 = 407;
export def SYS_ksem_destroy: u64 = 408;
export def SYS___mac_get_pid: u64 = 409;
export def SYS___mac_get_link: u64 = 410;
export def SYS___mac_set_link: u64 = 411;
export def SYS_extattr_set_link: u64 = 412;
export def SYS_extattr_get_link: u64 = 413;
export def SYS_extattr_delete_link: u64 = 414;
export def SYS___mac_execve: u64 = 415;
export def SYS_sigaction: u64 = 416;
export def SYS_sigreturn: u64 = 417;
export def SYS_getcontext: u64 = 421;
export def SYS_setcontext: u64 = 422;
export def SYS_swapcontext: u64 = 423;
export def SYS_swapoff: u64 = 424;
export def SYS___acl_get_link: u64 = 425;
export def SYS___acl_set_link: u64 = 426;
export def SYS___acl_delete_link: u64 = 427;
export def SYS___acl_aclcheck_link: u64 = 428;
export def SYS_sigwait: u64 = 429;
export def SYS_thr_create: u64 = 430;
export def SYS_thr_exit: u64 = 431;
export def SYS_thr_self: u64 = 432;
export def SYS_thr_kill: u64 = 433;
export def SYS_jail_attach: u64 = 436;
export def SYS_extattr_list_fd: u64 = 437;
export def SYS_extattr_list_file: u64 = 438;
export def SYS_extattr_list_link: u64 = 439;
export def SYS_ksem_timedwait: u64 = 441;
export def SYS_thr_suspend: u64 = 442;
export def SYS_thr_wake: u64 = 443;
export def SYS_kldunloadf: u64 = 444;
export def SYS_audit: u64 = 445;
export def SYS_auditon: u64 = 446;
export def SYS_getauid: u64 = 447;
export def SYS_setauid: u64 = 448;
export def SYS_getaudit: u64 = 449;
export def SYS_setaudit: u64 = 450;
export def SYS_getaudit_addr: u64 = 451;
export def SYS_setaudit_addr: u64 = 452;
export def SYS_auditctl: u64 = 453;
export def SYS__umtx_op: u64 = 454;
export def SYS_thr_new: u64 = 455;
export def SYS_sigqueue: u64 = 456;
export def SYS_kmq_open: u64 = 457;
export def SYS_kmq_setattr: u64 = 458;
export def SYS_kmq_timedreceive: u64 = 459;
export def SYS_kmq_timedsend: u64 = 460;
export def SYS_kmq_notify: u64 = 461;
export def SYS_kmq_unlink: u64 = 462;
export def SYS_abort2: u64 = 463;
export def SYS_thr_set_name: u64 = 464;
export def SYS_aio_fsync: u64 = 465;
export def SYS_rtprio_thread: u64 = 466;
export def SYS_sctp_peeloff: u64 = 471;
export def SYS_sctp_generic_sendmsg: u64 = 472;
export def SYS_sctp_generic_sendmsg_iov: u64 = 473;
export def SYS_sctp_generic_recvmsg: u64 = 474;
export def SYS_pread: u64 = 475;
export def SYS_pwrite: u64 = 476;
export def SYS_mmap: u64 = 477;
export def SYS_lseek: u64 = 478;
export def SYS_truncate: u64 = 479;
export def SYS_ftruncate: u64 = 480;
export def SYS_thr_kill2: u64 = 481;
export def SYS_freebsd12_shm_open: u64 = 482;
export def SYS_shm_unlink: u64 = 483;
export def SYS_cpuset: u64 = 484;
export def SYS_cpuset_setid: u64 = 485;
export def SYS_cpuset_getid: u64 = 486;
export def SYS_cpuset_getaffinity: u64 = 487;
export def SYS_cpuset_setaffinity: u64 = 488;
export def SYS_faccessat: u64 = 489;
export def SYS_fchmodat: u64 = 490;
export def SYS_fchownat: u64 = 491;
export def SYS_fexecve: u64 = 492;
export def SYS_freebsd11_fstatat: u64 = 493;
export def SYS_futimesat: u64 = 494;
export def SYS_linkat: u64 = 495;
export def SYS_mkdirat: u64 = 496;
export def SYS_mkfifoat: u64 = 497;
export def SYS_freebsd11_mknodat: u64 = 498;
export def SYS_openat: u64 = 499;
export def SYS_readlinkat: u64 = 500;
export def SYS_renameat: u64 = 501;
export def SYS_symlinkat: u64 = 502;
export def SYS_unlinkat: u64 = 503;
export def SYS_posix_openpt: u64 = 504;
export def SYS_gssd_syscall: u64 = 505;
export def SYS_jail_get: u64 = 506;
export def SYS_jail_set: u64 = 507;
export def SYS_jail_remove: u64 = 508;
export def SYS_freebsd12_closefrom: u64 = 509;
export def SYS___semctl: u64 = 510;
export def SYS_msgctl: u64 = 511;
export def SYS_shmctl: u64 = 512;
export def SYS_lpathconf: u64 = 513;
export def SYS___cap_rights_get: u64 = 515;
export def SYS_cap_enter: u64 = 516;
export def SYS_cap_getmode: u64 = 517;
export def SYS_pdfork: u64 = 518;
export def SYS_pdkill: u64 = 519;
export def SYS_pdgetpid: u64 = 520;
export def SYS_pselect: u64 = 522;
export def SYS_getloginclass: u64 = 523;
export def SYS_setloginclass: u64 = 524;
export def SYS_rctl_get_racct: u64 = 525;
export def SYS_rctl_get_rules: u64 = 526;
export def SYS_rctl_get_limits: u64 = 527;
export def SYS_rctl_add_rule: u64 = 528;
export def SYS_rctl_remove_rule: u64 = 529;
export def SYS_posix_fallocate: u64 = 530;
export def SYS_posix_fadvise: u64 = 531;
export def SYS_wait6: u64 = 532;
export def SYS_cap_rights_limit: u64 = 533;
export def SYS_cap_ioctls_limit: u64 = 534;
export def SYS_cap_ioctls_get: u64 = 535;
export def SYS_cap_fcntls_limit: u64 = 536;
export def SYS_cap_fcntls_get: u64 = 537;
export def SYS_bindat: u64 = 538;
export def SYS_connectat: u64 = 539;
export def SYS_chflagsat: u64 = 540;
export def SYS_accept4: u64 = 541;
export def SYS_pipe2: u64 = 542;
export def SYS_aio_mlock: u64 = 543;
export def SYS_procctl: u64 = 544;
export def SYS_ppoll: u64 = 545;
export def SYS_futimens: u64 = 546;
export def SYS_utimensat: u64 = 547;
export def SYS_fdatasync: u64 = 550;
export def SYS_fstat: u64 = 551;
export def SYS_fstatat: u64 = 552;
export def SYS_fhstat: u64 = 553;
export def SYS_getdirentries: u64 = 554;
export def SYS_statfs: u64 = 555;
export def SYS_fstatfs: u64 = 556;
export def SYS_getfsstat: u64 = 557;
export def SYS_fhstatfs: u64 = 558;
export def SYS_mknodat: u64 = 559;
export def SYS_kevent: u64 = 560;
export def SYS_cpuset_getdomain: u64 = 561;
export def SYS_cpuset_setdomain: u64 = 562;
export def SYS_getrandom: u64 = 563;
export def SYS_getfhat: u64 = 564;
export def SYS_fhlink: u64 = 565;
export def SYS_fhlinkat: u64 = 566;
export def SYS_fhreadlink: u64 = 567;
export def SYS_funlinkat: u64 = 568;
export def SYS_copy_file_range: u64 = 569;
export def SYS___sysctlbyname: u64 = 570;
export def SYS_shm_open2: u64 = 571;
export def SYS_shm_rename: u64 = 572;
export def SYS_sigfastblock: u64 = 573;
export def SYS___realpathat: u64 = 574;
export def SYS_close_range: u64 = 575;
export def SYS_rpctls_syscall: u64 = 576;
export def SYS___specialfd: u64 = 577;
export def SYS_aio_writev: u64 = 578;
export def SYS_aio_readv: u64 = 579;
0707010000002D000081A4000000000000000000000001654939DE00000AB8000000000000000000000000000000000000003100000000harec-1699297758.b4dd427/rt/+freebsd/syscalls.hafn syscall0(u64) u64;
fn syscall1(u64, u64) u64;
fn syscall2(u64, u64, u64) u64;
fn syscall3(u64, u64, u64, u64) u64;
fn syscall4(u64, u64, u64, u64, u64) u64;
fn syscall5(u64, u64, u64, u64, u64, u64) u64;
fn syscall6(u64, u64, u64, u64, u64, u64, u64) u64;

export fn write(fd: int, buf: *const opaque, count: size) size =
	syscall3(SYS_write, fd: u64, buf: uintptr: u64, count: u64): size;

export fn close(fd: int) int = syscall1(SYS_close, fd: u64): int;

export fn dup2(old: int, new: int) int =
	syscall2(SYS_dup2, old: u64, new: u64): int;

export fn getpid() int = syscall0(SYS_getpid): int;

export def EXIT_SUCCESS: int = 0;
export def EXIT_FAILURE: int = 1;

export fn exit(status: int) never = {
	syscall1(SYS_exit, status: u64);
	abort();
};

export fn fork() int = syscall0(SYS_fork): int;

export fn execve(
	path: *const u8,
	argv: *[*]nullable *const u8,
	envp: *[*]nullable *const u8,
) int = syscall3(SYS_execve,
	path: uintptr: u64,
	argv: uintptr: u64,
	envp: uintptr: u64): int;

export fn wait4(pid: int, status: *int, options: int, rusage: nullable *opaque) void = {
	syscall4(SYS_wait4, pid: u64, status: uintptr: u64,
		options: u64, rusage: uintptr: u64);
};

export fn wifexited(status: int) bool = wtermsig(status) == 0;
export fn wexitstatus(status: int) int = (status & 0xff00) >> 8;

export fn wtermsig(status: int) int = status & 0x7f;
export fn wifsignaled(status: int) bool =
	wtermsig(status) != 0o177 && wtermsig(status) != 0 && status != 0x13;

export fn kill(pid: int, signal: int) int =
	syscall2(SYS_kill, pid: u64, signal: u64): int;

export fn pipe2(pipefd: *[2]int, flags: int) int =
	syscall2(SYS_pipe2, pipefd: uintptr: u64, flags: u64): int;

export def MAP_SHARED: uint = 0x0001;
export def MAP_PRIVATE: uint = 0x0002;
export def MAP_FIXED: uint = 0x0010;
export def MAP_HASSEMAPHORE: uint = 0x0200;
export def MAP_STACK: uint = 0x0400;
export def MAP_NOSYNC: uint = 0x0800;
export def MAP_FILE: uint = 0x0000;
export def MAP_ANON: uint = 0x1000;
export def MAP_GUARD: uint = 0x00002000;
export def MAP_EXCL: uint = 0x00004000;
export def MAP_NOCORE: uint = 0x00020000;
export def MAP_PREFAULT_READ: uint = 0x00040000;
export def MAP_32BIT: uint = 0x00080000;

def PROT_NONE: uint = 0x00;
def PROT_READ: uint = 0x01;
def PROT_WRITE: uint = 0x02;
def PROT_EXEC: uint = 0x04;

export fn mmap(
	addr: nullable *opaque,
	length: size,
	prot: uint,
	flags: uint,
	fd: int,
	offs: size
) *opaque = {
	return syscall6(SYS_mmap, addr: uintptr: u64, length: u64, prot: u64,
		flags: u64, fd: u64, offs: u64): uintptr: *opaque;
};

export fn munmap(addr: *opaque, length: size) int =
	syscall2(SYS_munmap, addr: uintptr: u64, length: u64): int;

export def SIGABRT: int	= 6;
export def SIGCHLD: int	= 20;
0707010000002E000041ED000000000000000000000002654939DE00000000000000000000000000000000000000000000002300000000harec-1699297758.b4dd427/rt/+linux0707010000002F000081A4000000000000000000000001654939DE00001004000000000000000000000000000000000000002C00000000harec-1699297758.b4dd427/rt/+linux/errno.haexport def EPERM: int		= 1;
export def ENOENT: int		= 2;
export def ESRCH: int		= 3;
export def EINTR: int		= 4;
export def EIO: int		= 5;
export def ENXIO: int		= 6;
export def E2BIG: int		= 7;
export def ENOEXEC: int		= 8;
export def EBADF: int		= 9;
export def ECHILD: int		= 10;
export def EAGAIN: int		= 11;
export def ENOMEM: int		= 12;
export def EACCES: int		= 13;
export def EFAULT: int		= 14;
export def ENOTBLK: int		= 15;
export def EBUSY: int		= 16;
export def EEXIST: int		= 17;
export def EXDEV: int		= 18;
export def ENODEV: int		= 19;
export def ENOTDIR: int		= 20;
export def EISDIR: int		= 21;
export def EINVAL: int		= 22;
export def ENFILE: int		= 23;
export def EMFILE: int		= 24;
export def ENOTTY: int		= 25;
export def ETXTBSY: int		= 26;
export def EFBIG: int		= 27;
export def ENOSPC: int		= 28;
export def ESPIPE: int		= 29;
export def EROFS: int		= 30;
export def EMLINK: int		= 31;
export def EPIPE: int		= 32;
export def EDOM: int		= 33;
export def ERANGE: int		= 34;
export def EDEADLK: int		= 35;
export def ENAMETOOLONG: int	= 36;
export def ENOLCK: int		= 37;
export def ENOSYS: int		= 38;
export def ENOTEMPTY: int	= 39;
export def ELOOP: int		= 40;
export def ENOMSG: int		= 42;
export def EIDRM: int		= 43;
export def ECHRNG: int		= 44;
export def EL2NSYNC: int	= 45;
export def EL3HLT: int		= 46;
export def EL3RST: int		= 47;
export def ELNRNG: int		= 48;
export def EUNATCH: int		= 49;
export def ENOCSI: int		= 50;
export def EL2HLT: int		= 51;
export def EBADE: int		= 52;
export def EBADR: int		= 53;
export def EXFULL: int		= 54;
export def ENOANO: int		= 55;
export def EBADRQC: int		= 56;
export def EBADSLT: int		= 57;
export def EBFONT: int		= 59;
export def ENOSTR: int		= 60;
export def ENODATA: int		= 61;
export def ETIME: int		= 62;
export def ENOSR: int		= 63;
export def ENONET: int		= 64;
export def ENOPKG: int		= 65;
export def EREMOTE: int		= 66;
export def ENOLINK: int		= 67;
export def EADV: int		= 68;
export def ESRMNT: int		= 69;
export def ECOMM: int		= 70;
export def EPROTO: int		= 71;
export def EMULTIHOP: int	= 72;
export def EDOTDOT: int		= 73;
export def EBADMSG: int		= 74;
export def EOVERFLOW: int	= 75;
export def ENOTUNIQ: int	= 76;
export def EBADFD: int		= 77;
export def EREMCHG: int		= 78;
export def ELIBACC: int		= 79;
export def ELIBBAD: int		= 80;
export def ELIBSCN: int		= 81;
export def ELIBMAX: int		= 82;
export def ELIBEXEC: int	= 83;
export def EILSEQ: int		= 84;
export def ERESTART: int	= 85;
export def ESTRPIPE: int	= 86;
export def EUSERS: int		= 87;
export def ENOTSOCK: int	= 88;
export def EDESTADDRREQ: int	= 89;
export def EMSGSIZE: int	= 90;
export def EPROTOTYPE: int	= 91;
export def ENOPROTOOPT: int	= 92;
export def EPROTONOSUPPORT: int	= 93;
export def ESOCKTNOSUPPORT: int	= 94;
export def EOPNOTSUPP: int	= 95;
export def EPFNOSUPPORT: int	= 96;
export def EAFNOSUPPORT: int	= 97;
export def EADDRINUSE: int	= 98;
export def EADDRNOTAVAIL: int	= 99;
export def ENETDOWN: int	= 100;
export def ENETUNREACH: int	= 101;
export def ENETRESET: int	= 102;
export def ECONNABORTED: int	= 103;
export def ECONNRESET: int	= 104;
export def ENOBUFS: int		= 105;
export def EISCONN: int		= 106;
export def ENOTCONN: int	= 107;
export def ESHUTDOWN: int	= 108;
export def ETOOMANYREFS: int	= 109;
export def ETIMEDOUT: int	= 110;
export def ECONNREFUSED: int	= 111;
export def EHOSTDOWN: int	= 112;
export def EHOSTUNREACH: int	= 113;
export def EALREADY: int	= 114;
export def EINPROGRESS: int	= 115;
export def ESTALE: int		= 116;
export def EUCLEAN: int		= 117;
export def ENOTNAM: int		= 118;
export def ENAVAIL: int		= 119;
export def EISNAM: int		= 120;
export def EREMOTEIO: int	= 121;
export def EDQUOT: int		= 122;
export def ENOMEDIUM: int	= 123;
export def EMEDIUMTYPE: int	= 124;
export def ECANCELED: int	= 125;
export def ENOKEY: int		= 126;
export def EKEYEXPIRED: int	= 127;
export def EKEYREVOKED: int	= 128;
export def EKEYREJECTED: int	= 129;
export def EOWNERDEAD: int	= 130;
export def ENOTRECOVERABLE: int	= 131;
export def ERFKILL: int		= 132;
export def EHWPOISON: int	= 133;
07070100000030000081A4000000000000000000000001654939DE00000139000000000000000000000000000000000000003000000000harec-1699297758.b4dd427/rt/+linux/segmalloc.ha// Allocates a segment.
fn segmalloc(n: size) nullable *opaque = {
	let p: *opaque = mmap(null, n,
		PROT_READ | PROT_WRITE,
		MAP_PRIVATE | MAP_ANON, -1, 0);
	return if (p: uintptr: int == -ENOMEM) null else p;
};

// Frees a segment allocated with segmalloc.
fn segfree(p: *opaque, s: size) int = munmap(p, s);
07070100000031000081A4000000000000000000000001654939DE00000064000000000000000000000000000000000000003300000000harec-1699297758.b4dd427/rt/+linux/start+aarch64.s.text
.global _start
_start:
	mov x29, #0
	mov x30, #0
	mov x0, sp
	add sp, x0, #-16
	b rt.start_ha
07070100000032000081A4000000000000000000000001654939DE0000004C000000000000000000000000000000000000003300000000harec-1699297758.b4dd427/rt/+linux/start+riscv64.s.text
.global _start
_start:
	mv a0, sp
	andi sp, sp, -16
	tail rt.start_ha
07070100000033000081A4000000000000000000000001654939DE00000061000000000000000000000000000000000000003200000000harec-1699297758.b4dd427/rt/+linux/start+x86_64.s.text
.global _start
_start:
	xor %rbp, %rbp
	movq %rsp, %rdi
	andq $-16, %rsp
	call rt.start_ha
07070100000034000081A4000000000000000000000001654939DE0000034E000000000000000000000000000000000000003500000000harec-1699297758.b4dd427/rt/+linux/syscall+aarch64.s.section .text.rt.syscall0
.global rt.syscall0
rt.syscall0:
	mov x8, x0
	svc 0
	ret

.section .text.rt.syscall1
.global rt.syscall1
rt.syscall1:
	mov x8, x0
	mov x0, x1
	svc 0
	ret

.section .text.rt.syscall2
.global rt.syscall2
rt.syscall2:
	mov x8, x0
	mov x0, x1
	mov x1, x2
	svc 0
	ret

.section .text.rt.syscall3
.global rt.syscall3
rt.syscall3:
	mov x8, x0
	mov x0, x1
	mov x1, x2
	mov x2, x3
	svc 0
	ret

.section .text.rt.syscall4
.global rt.syscall4
rt.syscall4:
	mov x8, x0
	mov x0, x1
	mov x1, x2
	mov x2, x3
	mov x3, x4
	svc 0
	ret

.section .text.rt.syscall5
.global rt.syscall5
rt.syscall5:
	mov x8, x0
	mov x0, x1
	mov x1, x2
	mov x2, x3
	mov x3, x4
	mov x4, x5
	svc 0
	ret

.section .text.rt.syscall6
.global rt.syscall6
rt.syscall6:
	mov x8, x0
	mov x0, x1
	mov x1, x2
	mov x2, x3
	mov x3, x4
	mov x4, x5
	mov x5, x6
	svc 0
	ret
07070100000035000081A4000000000000000000000001654939DE00000332000000000000000000000000000000000000003500000000harec-1699297758.b4dd427/rt/+linux/syscall+riscv64.s.section .text.rt.syscall0
.global rt.syscall0
rt.syscall0:
	mv a7, a0
	ecall
	ret

.section .text.rt.syscall1
.global rt.syscall1
rt.syscall1:
	mv a7, a0
	mv a0, a1
	ecall
	ret

.section .text.rt.syscall2
.global rt.syscall2
rt.syscall2:
	mv a7, a0
	mv a0, a1
	mv a1, a2
	ecall
	ret

.section .text.rt.syscall3
.global rt.syscall3
rt.syscall3:
	mv a7, a0
	mv a0, a1
	mv a1, a2
	mv a2, a3
	ecall
	ret

.section .text.rt.syscall4
.global rt.syscall4
rt.syscall4:
	mv a7, a0
	mv a0, a1
	mv a1, a2
	mv a2, a3
	mv a3, a4
	ecall
	ret

.section .text.rt.syscall5
.global rt.syscall5
rt.syscall5:
	mv a7, a0
	mv a0, a1
	mv a1, a2
	mv a2, a3
	mv a3, a4
	mv a4, a5
	ecall
	ret

.section .text.rt.syscall6
.global rt.syscall6
rt.syscall6:
	mv a7, a0
	mv a0, a1
	mv a1, a2
	mv a2, a3
	mv a3, a4
	mv a4, a5
	mv a5, a6
	ecall
	ret
07070100000036000081A4000000000000000000000001654939DE000003E3000000000000000000000000000000000000003400000000harec-1699297758.b4dd427/rt/+linux/syscall+x86_64.s.section .text.rt.syscall0
.global rt.syscall0
rt.syscall0:
	movq %rdi, %rax
	syscall
	ret

.section .text.rt.syscall1
.global rt.syscall1
rt.syscall1:
	movq %rdi, %rax
	movq %rsi, %rdi
	syscall
	ret

.section .text.rt.syscall2
.global rt.syscall2
rt.syscall2:
	movq %rdi, %rax
	movq %rsi, %rdi
	movq %rdx, %rsi
	syscall
	ret

.section .text.rt.syscall3
.global rt.syscall3
rt.syscall3:
	movq %rdi, %rax
	movq %rsi, %rdi
	movq %rdx, %rsi
	movq %rcx, %rdx
	syscall
	ret

.section .text.rt.syscall4
.global rt.syscall4
rt.syscall4:
	movq %rdi, %rax
	movq %r8, %r10
	movq %rsi, %rdi
	movq %rdx, %rsi
	movq %rcx, %rdx
	syscall
	ret

.section .text.rt.syscall5
.global rt.syscall5
rt.syscall5:
	movq %rdi, %rax
	movq %r8, %r10
	movq %rsi, %rdi
	movq %r9, %r8
	movq %rdx, %rsi
	movq %rcx, %rdx
	syscall
	ret

.section .text.rt.syscall6
.global rt.syscall6
rt.syscall6:
	movq %rdi, %rax
	movq %r8, %r10
	movq %rsi, %rdi
	movq %r9, %r8
	movq %rdx, %rsi
	movq 8(%rsp), %r9
	movq %rcx, %rdx
	syscall
	ret
07070100000037000081A4000000000000000000000001654939DE00002BBA000000000000000000000000000000000000003800000000harec-1699297758.b4dd427/rt/+linux/syscallno+aarch64.haexport def SYS_io_setup: u64			= 0;
export def SYS_io_destroy: u64			= 1;
export def SYS_io_submit: u64			= 2;
export def SYS_io_cancel: u64			= 3;
export def SYS_io_getevents: u64		= 4;
export def SYS_setxattr: u64			= 5;
export def SYS_lsetxattr: u64			= 6;
export def SYS_fsetxattr: u64			= 7;
export def SYS_getxattr: u64			= 8;
export def SYS_lgetxattr: u64			= 9;
export def SYS_fgetxattr: u64			= 10;
export def SYS_listxattr: u64			= 11;
export def SYS_llistxattr: u64			= 12;
export def SYS_flistxattr: u64			= 13;
export def SYS_removexattr: u64			= 14;
export def SYS_lremovexattr: u64		= 15;
export def SYS_fremovexattr: u64		= 16;
export def SYS_getcwd: u64			= 17;
export def SYS_lookup_dcookie: u64		= 18;
export def SYS_eventfd2: u64			= 19;
export def SYS_epoll_create1: u64		= 20;
export def SYS_epoll_ctl: u64			= 21;
export def SYS_epoll_pwait: u64			= 22;
export def SYS_dup: u64				= 23;
export def SYS_dup3: u64			= 24;
export def SYS_fcntl: u64			= 25;
export def SYS_inotify_init1: u64		= 26;
export def SYS_inotify_add_watch: u64		= 27;
export def SYS_inotify_rm_watch: u64		= 28;
export def SYS_ioctl: u64			= 29;
export def SYS_ioprio_set: u64			= 30;
export def SYS_ioprio_get: u64			= 31;
export def SYS_flock: u64			= 32;
export def SYS_mknodat: u64			= 33;
export def SYS_mkdirat: u64			= 34;
export def SYS_unlinkat: u64			= 35;
export def SYS_symlinkat: u64			= 36;
export def SYS_linkat: u64			= 37;
export def SYS_renameat: u64			= 38;
export def SYS_umount2: u64			= 39;
export def SYS_mount: u64			= 40;
export def SYS_pivot_root: u64			= 41;
export def SYS_nfsservctl: u64			= 42;
export def SYS_statfs: u64			= 43;
export def SYS_fstatfs: u64			= 44;
export def SYS_truncate: u64			= 45;
export def SYS_ftruncate: u64			= 46;
export def SYS_fallocate: u64			= 47;
export def SYS_faccessat: u64			= 48;
export def SYS_chdir: u64			= 49;
export def SYS_fchdir: u64			= 50;
export def SYS_chroot: u64			= 51;
export def SYS_fchmod: u64			= 52;
export def SYS_fchmodat: u64			= 53;
export def SYS_fchownat: u64			= 54;
export def SYS_fchown: u64			= 55;
export def SYS_openat: u64			= 56;
export def SYS_close: u64			= 57;
export def SYS_vhangup: u64			= 58;
export def SYS_pipe2: u64			= 59;
export def SYS_quotactl: u64			= 60;
export def SYS_getdents64: u64			= 61;
export def SYS_lseek: u64			= 62;
export def SYS_read: u64			= 63;
export def SYS_write: u64			= 64;
export def SYS_readv: u64			= 65;
export def SYS_writev: u64			= 66;
export def SYS_pread64: u64			= 67;
export def SYS_pwrite64: u64			= 68;
export def SYS_preadv: u64			= 69;
export def SYS_pwritev: u64			= 70;
export def SYS_sendfile: u64			= 71;
export def SYS_pselect6: u64			= 72;
export def SYS_ppoll: u64			= 73;
export def SYS_signalfd4: u64			= 74;
export def SYS_vmsplice: u64			= 75;
export def SYS_splice: u64			= 76;
export def SYS_tee: u64				= 77;
export def SYS_readlinkat: u64			= 78;
export def SYS_newfstatat: u64			= 79;
export def SYS_fstat: u64			= 80;
export def SYS_sync: u64			= 81;
export def SYS_fsync: u64			= 82;
export def SYS_fdatasync: u64			= 83;
export def SYS_sync_file_range: u64		= 84;
export def SYS_timerfd_create: u64		= 85;
export def SYS_timerfd_settime: u64		= 86;
export def SYS_timerfd_gettime: u64		= 87;
export def SYS_utimensat: u64			= 88;
export def SYS_acct: u64			= 89;
export def SYS_capget: u64			= 90;
export def SYS_capset: u64			= 91;
export def SYS_personality: u64			= 92;
export def SYS_exit: u64			= 93;
export def SYS_exit_group: u64			= 94;
export def SYS_waitid: u64			= 95;
export def SYS_set_tid_address: u64		= 96;
export def SYS_unshare: u64			= 97;
export def SYS_futex: u64			= 98;
export def SYS_set_robust_list: u64		= 99;
export def SYS_get_robust_list: u64		= 100;
export def SYS_nanosleep: u64			= 101;
export def SYS_getitimer: u64			= 102;
export def SYS_setitimer: u64			= 103;
export def SYS_kexec_load: u64			= 104;
export def SYS_init_module: u64			= 105;
export def SYS_delete_module: u64		= 106;
export def SYS_timer_create: u64		= 107;
export def SYS_timer_gettime: u64		= 108;
export def SYS_timer_getoverrun: u64		= 109;
export def SYS_timer_settime: u64		= 110;
export def SYS_timer_delete: u64		= 111;
export def SYS_clock_settime: u64		= 112;
export def SYS_clock_gettime: u64		= 113;
export def SYS_clock_getres: u64		= 114;
export def SYS_clock_nanosleep: u64		= 115;
export def SYS_syslog: u64			= 116;
export def SYS_ptrace: u64			= 117;
export def SYS_sched_setparam: u64		= 118;
export def SYS_sched_setscheduler: u64		= 119;
export def SYS_sched_getscheduler: u64		= 120;
export def SYS_sched_getparam: u64		= 121;
export def SYS_sched_setaffinity: u64		= 122;
export def SYS_sched_getaffinity: u64		= 123;
export def SYS_sched_yield: u64			= 124;
export def SYS_sched_get_priority_max: u64	= 125;
export def SYS_sched_get_priority_min: u64	= 126;
export def SYS_sched_rr_get_interval: u64	= 127;
export def SYS_restart_syscall: u64		= 128;
export def SYS_kill: u64			= 129;
export def SYS_tkill: u64			= 130;
export def SYS_tgkill: u64			= 131;
export def SYS_sigaltstack: u64			= 132;
export def SYS_rt_sigsuspend: u64		= 133;
export def SYS_rt_sigaction: u64		= 134;
export def SYS_rt_sigprocmask: u64		= 135;
export def SYS_rt_sigpending: u64		= 136;
export def SYS_rt_sigtimedwait: u64		= 137;
export def SYS_rt_sigqueueinfo: u64		= 138;
export def SYS_rt_sigreturn: u64		= 139;
export def SYS_setpriority: u64			= 140;
export def SYS_getpriority: u64			= 141;
export def SYS_reboot: u64			= 142;
export def SYS_setregid: u64			= 143;
export def SYS_setgid: u64			= 144;
export def SYS_setreuid: u64			= 145;
export def SYS_setuid: u64			= 146;
export def SYS_setresuid: u64			= 147;
export def SYS_getresuid: u64			= 148;
export def SYS_setresgid: u64			= 149;
export def SYS_getresgid: u64			= 150;
export def SYS_setfsuid: u64			= 151;
export def SYS_setfsgid: u64			= 152;
export def SYS_times: u64			= 153;
export def SYS_setpgid: u64			= 154;
export def SYS_getpgid: u64			= 155;
export def SYS_getsid: u64			= 156;
export def SYS_setsid: u64			= 157;
export def SYS_getgroups: u64			= 158;
export def SYS_setgroups: u64			= 159;
export def SYS_uname: u64			= 160;
export def SYS_sethostname: u64			= 161;
export def SYS_setdomainname: u64		= 162;
export def SYS_getrlimit: u64			= 163;
export def SYS_setrlimit: u64			= 164;
export def SYS_getrusage: u64			= 165;
export def SYS_umask: u64			= 166;
export def SYS_prctl: u64			= 167;
export def SYS_getcpu: u64			= 168;
export def SYS_gettimeofday: u64		= 169;
export def SYS_settimeofday: u64		= 170;
export def SYS_adjtimex: u64			= 171;
export def SYS_getpid: u64			= 172;
export def SYS_getppid: u64			= 173;
export def SYS_getuid: u64			= 174;
export def SYS_geteuid: u64			= 175;
export def SYS_getgid: u64			= 176;
export def SYS_getegid: u64			= 177;
export def SYS_gettid: u64			= 178;
export def SYS_sysinfo: u64			= 179;
export def SYS_mq_open: u64			= 180;
export def SYS_mq_unlink: u64			= 181;
export def SYS_mq_timedsend: u64		= 182;
export def SYS_mq_timedreceive: u64		= 183;
export def SYS_mq_notify: u64			= 184;
export def SYS_mq_getsetattr: u64		= 185;
export def SYS_msgget: u64			= 186;
export def SYS_msgctl: u64			= 187;
export def SYS_msgrcv: u64			= 188;
export def SYS_msgsnd: u64			= 189;
export def SYS_semget: u64			= 190;
export def SYS_semctl: u64			= 191;
export def SYS_semtimedop: u64			= 192;
export def SYS_semop: u64			= 193;
export def SYS_shmget: u64			= 194;
export def SYS_shmctl: u64			= 195;
export def SYS_shmat: u64			= 196;
export def SYS_shmdt: u64			= 197;
export def SYS_socket: u64			= 198;
export def SYS_socketpair: u64			= 199;
export def SYS_bind: u64			= 200;
export def SYS_listen: u64			= 201;
export def SYS_accept: u64			= 202;
export def SYS_connect: u64			= 203;
export def SYS_getsockname: u64			= 204;
export def SYS_getpeername: u64			= 205;
export def SYS_sendto: u64			= 206;
export def SYS_recvfrom: u64			= 207;
export def SYS_setsockopt: u64			= 208;
export def SYS_getsockopt: u64			= 209;
export def SYS_shutdown: u64			= 210;
export def SYS_sendmsg: u64			= 211;
export def SYS_recvmsg: u64			= 212;
export def SYS_readahead: u64			= 213;
export def SYS_brk: u64				= 214;
export def SYS_munmap: u64			= 215;
export def SYS_mremap: u64			= 216;
export def SYS_add_key: u64			= 217;
export def SYS_request_key: u64			= 218;
export def SYS_keyctl: u64			= 219;
export def SYS_clone: u64			= 220;
export def SYS_execve: u64			= 221;
export def SYS_mmap: u64			= 222;
export def SYS_fadvise64: u64			= 223;
export def SYS_swapon: u64			= 224;
export def SYS_swapoff: u64			= 225;
export def SYS_mprotect: u64			= 226;
export def SYS_msync: u64			= 227;
export def SYS_mlock: u64			= 228;
export def SYS_munlock: u64			= 229;
export def SYS_mlockall: u64			= 230;
export def SYS_munlockall: u64			= 231;
export def SYS_mincore: u64			= 232;
export def SYS_madvise: u64			= 233;
export def SYS_remap_file_pages: u64		= 234;
export def SYS_mbind: u64			= 235;
export def SYS_get_mempolicy: u64		= 236;
export def SYS_set_mempolicy: u64		= 237;
export def SYS_migrate_pages: u64		= 238;
export def SYS_move_pages: u64			= 239;
export def SYS_rt_tgsigqueueinfo: u64		= 240;
export def SYS_perf_event_open: u64		= 241;
export def SYS_accept4: u64			= 242;
export def SYS_recvmmsg: u64			= 243;
export def SYS_wait4: u64			= 260;
export def SYS_prlimit64: u64			= 261;
export def SYS_fanotify_init: u64		= 262;
export def SYS_fanotify_mark: u64		= 263;
export def SYS_name_to_handle_at: u64		= 264;
export def SYS_open_by_handle_at: u64		= 265;
export def SYS_clock_adjtime: u64		= 266;
export def SYS_syncfs: u64			= 267;
export def SYS_setns: u64			= 268;
export def SYS_sendmmsg: u64			= 269;
export def SYS_process_vm_readv: u64		= 270;
export def SYS_process_vm_writev: u64		= 271;
export def SYS_kcmp: u64			= 272;
export def SYS_finit_module: u64		= 273;
export def SYS_sched_setattr: u64		= 274;
export def SYS_sched_getattr: u64		= 275;
export def SYS_renameat2: u64			= 276;
export def SYS_seccomp: u64			= 277;
export def SYS_getrandom: u64			= 278;
export def SYS_memfd_create: u64		= 279;
export def SYS_bpf: u64				= 280;
export def SYS_execveat: u64			= 281;
export def SYS_userfaultfd: u64			= 282;
export def SYS_membarrier: u64			= 283;
export def SYS_mlock2: u64			= 284;
export def SYS_copy_file_range: u64		= 285;
export def SYS_preadv2: u64			= 286;
export def SYS_pwritev2: u64			= 287;
export def SYS_pkey_mprotect: u64		= 288;
export def SYS_pkey_alloc: u64			= 289;
export def SYS_pkey_free: u64			= 290;
export def SYS_statx: u64			= 291;
export def SYS_io_pgetevents: u64		= 292;
export def SYS_rseq: u64			= 293;
export def SYS_kexec_file_load: u64		= 294;
export def SYS_pidfd_send_signal: u64		= 424;
export def SYS_io_uring_setup: u64		= 425;
export def SYS_io_uring_enter: u64		= 426;
export def SYS_io_uring_register: u64		= 427;
export def SYS_open_tree: u64			= 428;
export def SYS_move_mount: u64			= 429;
export def SYS_fsopen: u64			= 430;
export def SYS_fsconfig: u64			= 431;
export def SYS_fsmount: u64			= 432;
export def SYS_fspick: u64			= 433;
export def SYS_pidfd_open: u64			= 434;
export def SYS_clone3: u64			= 435;
07070100000038000081A4000000000000000000000001654939DE00002AE8000000000000000000000000000000000000003800000000harec-1699297758.b4dd427/rt/+linux/syscallno+riscv64.haexport def SYS_io_setup: u64 = 0;
export def SYS_io_destroy: u64 = 1;
export def SYS_io_submit: u64 = 2;
export def SYS_io_cancel: u64 = 3;
export def SYS_io_getevents: u64 = 4;
export def SYS_setxattr: u64 = 5;
export def SYS_lsetxattr: u64 = 6;
export def SYS_fsetxattr: u64 = 7;
export def SYS_getxattr: u64 = 8;
export def SYS_lgetxattr: u64 = 9;
export def SYS_fgetxattr: u64 = 10;
export def SYS_listxattr: u64 = 11;
export def SYS_llistxattr: u64 = 12;
export def SYS_flistxattr: u64 = 13;
export def SYS_removexattr: u64 = 14;
export def SYS_lremovexattr: u64 = 15;
export def SYS_fremovexattr: u64 = 16;
export def SYS_getcwd: u64 = 17;
export def SYS_lookup_dcookie: u64 = 18;
export def SYS_eventfd2: u64 = 19;
export def SYS_epoll_create1: u64 = 20;
export def SYS_epoll_ctl: u64 = 21;
export def SYS_epoll_pwait: u64 = 22;
export def SYS_dup: u64 = 23;
export def SYS_dup3: u64 = 24;
export def SYS_fcntl: u64 = 25;
export def SYS_inotify_init1: u64 = 26;
export def SYS_inotify_add_watch: u64 = 27;
export def SYS_inotify_rm_watch: u64 = 28;
export def SYS_ioctl: u64 = 29;
export def SYS_ioprio_set: u64 = 30;
export def SYS_ioprio_get: u64 = 31;
export def SYS_flock: u64 = 32;
export def SYS_mknodat: u64 = 33;
export def SYS_mkdirat: u64 = 34;
export def SYS_unlinkat: u64 = 35;
export def SYS_symlinkat: u64 = 36;
export def SYS_linkat: u64 = 37;
export def SYS_umount2: u64 = 39;
export def SYS_mount: u64 = 40;
export def SYS_pivot_root: u64 = 41;
export def SYS_nfsservctl: u64 = 42;
export def SYS_statfs: u64 = 43;
export def SYS_fstatfs: u64 = 44;
export def SYS_truncate: u64 = 45;
export def SYS_ftruncate: u64 = 46;
export def SYS_fallocate: u64 = 47;
export def SYS_faccessat: u64 = 48;
export def SYS_chdir: u64 = 49;
export def SYS_fchdir: u64 = 50;
export def SYS_chroot: u64 = 51;
export def SYS_fchmod: u64 = 52;
export def SYS_fchmodat: u64 = 53;
export def SYS_fchownat: u64 = 54;
export def SYS_fchown: u64 = 55;
export def SYS_openat: u64 = 56;
export def SYS_close: u64 = 57;
export def SYS_vhangup: u64 = 58;
export def SYS_pipe2: u64 = 59;
export def SYS_quotactl: u64 = 60;
export def SYS_getdents64: u64 = 61;
export def SYS_lseek: u64 = 62;
export def SYS_read: u64 = 63;
export def SYS_write: u64 = 64;
export def SYS_readv: u64 = 65;
export def SYS_writev: u64 = 66;
export def SYS_pread64: u64 = 67;
export def SYS_pwrite64: u64 = 68;
export def SYS_preadv: u64 = 69;
export def SYS_pwritev: u64 = 70;
export def SYS_sendfile: u64 = 71;
export def SYS_pselect6: u64 = 72;
export def SYS_ppoll: u64 = 73;
export def SYS_signalfd4: u64 = 74;
export def SYS_vmsplice: u64 = 75;
export def SYS_splice: u64 = 76;
export def SYS_tee: u64 = 77;
export def SYS_readlinkat: u64 = 78;
export def SYS_fstatat: u64 = 79;
export def SYS_fstat: u64 = 80;
export def SYS_sync: u64 = 81;
export def SYS_fsync: u64 = 82;
export def SYS_fdatasync: u64 = 83;
export def SYS_sync_file_range: u64 = 84;
export def SYS_timerfd_create: u64 = 85;
export def SYS_timerfd_settime: u64 = 86;
export def SYS_timerfd_gettime: u64 = 87;
export def SYS_utimensat: u64 = 88;
export def SYS_acct: u64 = 89;
export def SYS_capget: u64 = 90;
export def SYS_capset: u64 = 91;
export def SYS_personality: u64 = 92;
export def SYS_exit: u64 = 93;
export def SYS_exit_group: u64 = 94;
export def SYS_waitid: u64 = 95;
export def SYS_set_tid_address: u64 = 96;
export def SYS_unshare: u64 = 97;
export def SYS_futex: u64 = 98;
export def SYS_set_robust_list: u64 = 99;
export def SYS_get_robust_list: u64 = 100;
export def SYS_nanosleep: u64 = 101;
export def SYS_getitimer: u64 = 102;
export def SYS_setitimer: u64 = 103;
export def SYS_kexec_load: u64 = 104;
export def SYS_init_module: u64 = 105;
export def SYS_delete_module: u64 = 106;
export def SYS_timer_create: u64 = 107;
export def SYS_timer_gettime: u64 = 108;
export def SYS_timer_getoverrun: u64 = 109;
export def SYS_timer_settime: u64 = 110;
export def SYS_timer_delete: u64 = 111;
export def SYS_clock_settime: u64 = 112;
export def SYS_clock_gettime: u64 = 113;
export def SYS_clock_getres: u64 = 114;
export def SYS_clock_nanosleep: u64 = 115;
export def SYS_syslog: u64 = 116;
export def SYS_ptrace: u64 = 117;
export def SYS_sched_setparam: u64 = 118;
export def SYS_sched_setscheduler: u64 = 119;
export def SYS_sched_getscheduler: u64 = 120;
export def SYS_sched_getparam: u64 = 121;
export def SYS_sched_setaffinity: u64 = 122;
export def SYS_sched_getaffinity: u64 = 123;
export def SYS_sched_yield: u64 = 124;
export def SYS_sched_get_priority_max: u64 = 125;
export def SYS_sched_get_priority_min: u64 = 126;
export def SYS_sched_rr_get_interval: u64 = 127;
export def SYS_restart_syscall: u64 = 128;
export def SYS_kill: u64 = 129;
export def SYS_tkill: u64 = 130;
export def SYS_tgkill: u64 = 131;
export def SYS_sigaltstack: u64 = 132;
export def SYS_rt_sigsuspend: u64 = 133;
export def SYS_rt_sigaction: u64 = 134;
export def SYS_rt_sigprocmask: u64 = 135;
export def SYS_rt_sigpending: u64 = 136;
export def SYS_rt_sigtimedwait: u64 = 137;
export def SYS_rt_sigqueueinfo: u64 = 138;
export def SYS_rt_sigreturn: u64 = 139;
export def SYS_setpriority: u64 = 140;
export def SYS_getpriority: u64 = 141;
export def SYS_reboot: u64 = 142;
export def SYS_setregid: u64 = 143;
export def SYS_setgid: u64 = 144;
export def SYS_setreuid: u64 = 145;
export def SYS_setuid: u64 = 146;
export def SYS_setresuid: u64 = 147;
export def SYS_getresuid: u64 = 148;
export def SYS_setresgid: u64 = 149;
export def SYS_getresgid: u64 = 150;
export def SYS_setfsuid: u64 = 151;
export def SYS_setfsgid: u64 = 152;
export def SYS_times: u64 = 153;
export def SYS_setpgid: u64 = 154;
export def SYS_getpgid: u64 = 155;
export def SYS_getsid: u64 = 156;
export def SYS_setsid: u64 = 157;
export def SYS_getgroups: u64 = 158;
export def SYS_setgroups: u64 = 159;
export def SYS_uname: u64 = 160;
export def SYS_sethostname: u64 = 161;
export def SYS_setdomainname: u64 = 162;
export def SYS_getrlimit: u64 = 163;
export def SYS_setrlimit: u64 = 164;
export def SYS_getrusage: u64 = 165;
export def SYS_umask: u64 = 166;
export def SYS_prctl: u64 = 167;
export def SYS_getcpu: u64 = 168;
export def SYS_gettimeofday: u64 = 169;
export def SYS_settimeofday: u64 = 170;
export def SYS_adjtimex: u64 = 171;
export def SYS_getpid: u64 = 172;
export def SYS_getppid: u64 = 173;
export def SYS_getuid: u64 = 174;
export def SYS_geteuid: u64 = 175;
export def SYS_getgid: u64 = 176;
export def SYS_getegid: u64 = 177;
export def SYS_gettid: u64 = 178;
export def SYS_sysinfo: u64 = 179;
export def SYS_mq_open: u64 = 180;
export def SYS_mq_unlink: u64 = 181;
export def SYS_mq_timedsend: u64 = 182;
export def SYS_mq_timedreceive: u64 = 183;
export def SYS_mq_notify: u64 = 184;
export def SYS_mq_getsetattr: u64 = 185;
export def SYS_msgget: u64 = 186;
export def SYS_msgctl: u64 = 187;
export def SYS_msgrcv: u64 = 188;
export def SYS_msgsnd: u64 = 189;
export def SYS_semget: u64 = 190;
export def SYS_semctl: u64 = 191;
export def SYS_semtimedop: u64 = 192;
export def SYS_semop: u64 = 193;
export def SYS_shmget: u64 = 194;
export def SYS_shmctl: u64 = 195;
export def SYS_shmat: u64 = 196;
export def SYS_shmdt: u64 = 197;
export def SYS_socket: u64 = 198;
export def SYS_socketpair: u64 = 199;
export def SYS_bind: u64 = 200;
export def SYS_listen: u64 = 201;
export def SYS_accept: u64 = 202;
export def SYS_connect: u64 = 203;
export def SYS_getsockname: u64 = 204;
export def SYS_getpeername: u64 = 205;
export def SYS_sendto: u64 = 206;
export def SYS_recvfrom: u64 = 207;
export def SYS_setsockopt: u64 = 208;
export def SYS_getsockopt: u64 = 209;
export def SYS_shutdown: u64 = 210;
export def SYS_sendmsg: u64 = 211;
export def SYS_recvmsg: u64 = 212;
export def SYS_readahead: u64 = 213;
export def SYS_brk: u64 = 214;
export def SYS_munmap: u64 = 215;
export def SYS_mremap: u64 = 216;
export def SYS_add_key: u64 = 217;
export def SYS_request_key: u64 = 218;
export def SYS_keyctl: u64 = 219;
export def SYS_clone: u64 = 220;
export def SYS_execve: u64 = 221;
export def SYS_mmap: u64 = 222;
export def SYS_fadvise64: u64 = 223;
export def SYS_swapon: u64 = 224;
export def SYS_swapoff: u64 = 225;
export def SYS_mprotect: u64 = 226;
export def SYS_msync: u64 = 227;
export def SYS_mlock: u64 = 228;
export def SYS_munlock: u64 = 229;
export def SYS_mlockall: u64 = 230;
export def SYS_munlockall: u64 = 231;
export def SYS_mincore: u64 = 232;
export def SYS_madvise: u64 = 233;
export def SYS_remap_file_pages: u64 = 234;
export def SYS_mbind: u64 = 235;
export def SYS_get_mempolicy: u64 = 236;
export def SYS_set_mempolicy: u64 = 237;
export def SYS_migrate_pages: u64 = 238;
export def SYS_move_pages: u64 = 239;
export def SYS_rt_tgsigqueueinfo: u64 = 240;
export def SYS_perf_event_open: u64 = 241;
export def SYS_accept4: u64 = 242;
export def SYS_recvmmsg: u64 = 243;
export def SYS_arch_specific_syscall: u64 = 244;
export def SYS_wait4: u64 = 260;
export def SYS_prlimit64: u64 = 261;
export def SYS_fanotify_init: u64 = 262;
export def SYS_fanotify_mark: u64 = 263;
export def SYS_name_to_handle_at: u64 = 264;
export def SYS_open_by_handle_at: u64 = 265;
export def SYS_clock_adjtime: u64 = 266;
export def SYS_syncfs: u64 = 267;
export def SYS_setns: u64 = 268;
export def SYS_sendmmsg: u64 = 269;
export def SYS_process_vm_readv: u64 = 270;
export def SYS_process_vm_writev: u64 = 271;
export def SYS_kcmp: u64 = 272;
export def SYS_finit_module: u64 = 273;
export def SYS_sched_setattr: u64 = 274;
export def SYS_sched_getattr: u64 = 275;
export def SYS_renameat2: u64 = 276;
export def SYS_seccomp: u64 = 277;
export def SYS_getrandom: u64 = 278;
export def SYS_memfd_create: u64 = 279;
export def SYS_bpf: u64 = 280;
export def SYS_execveat: u64 = 281;
export def SYS_userfaultfd: u64 = 282;
export def SYS_membarrier: u64 = 283;
export def SYS_mlock2: u64 = 284;
export def SYS_copy_file_range: u64 = 285;
export def SYS_preadv2: u64 = 286;
export def SYS_pwritev2: u64 = 287;
export def SYS_pkey_mprotect: u64 = 288;
export def SYS_pkey_alloc: u64 = 289;
export def SYS_pkey_free: u64 = 290;
export def SYS_statx: u64 = 291;
export def SYS_io_pgetevents: u64 = 292;
export def SYS_rseq: u64 = 293;
export def SYS_kexec_file_load: u64 = 294;
export def SYS_pidfd_send_signal: u64 = 424;
export def SYS_io_uring_setup: u64 = 425;
export def SYS_io_uring_enter: u64 = 426;
export def SYS_io_uring_register: u64 = 427;
export def SYS_open_tree: u64 = 428;
export def SYS_move_mount: u64 = 429;
export def SYS_fsopen: u64 = 430;
export def SYS_fsconfig: u64 = 431;
export def SYS_fsmount: u64 = 432;
export def SYS_fspick: u64 = 433;
export def SYS_pidfd_open: u64 = 434;
export def SYS_clone3: u64 = 435;
export def SYS_close_range: u64 = 436;
export def SYS_openat2: u64 = 437;
export def SYS_pidfd_getfd: u64 = 438;
export def SYS_faccessat2: u64 = 439;

// RISC-V specific
export def SYS_sysriscv: u64 = SYS_arch_specific_syscall;
export def SYS_riscv_flush_icache: u64 = SYS_sysriscv + 15;
07070100000039000081A4000000000000000000000001654939DE0000338D000000000000000000000000000000000000003700000000harec-1699297758.b4dd427/rt/+linux/syscallno+x86_64.haexport def SYS_read: u64			= 0;
export def SYS_write: u64			= 1;
export def SYS_open: u64			= 2;
export def SYS_close: u64			= 3;
export def SYS_stat: u64			= 4;
export def SYS_fstat: u64			= 5;
export def SYS_lstat: u64			= 6;
export def SYS_poll: u64			= 7;
export def SYS_lseek: u64			= 8;
export def SYS_mmap: u64			= 9;
export def SYS_mprotect: u64			= 10;
export def SYS_munmap: u64			= 11;
export def SYS_brk: u64				= 12;
export def SYS_rt_sigaction: u64		= 13;
export def SYS_rt_sigprocmask: u64		= 14;
export def SYS_rt_sigreturn: u64		= 15;
export def SYS_ioctl: u64			= 16;
export def SYS_pread64: u64			= 17;
export def SYS_pwrite64: u64			= 18;
export def SYS_readv: u64			= 19;
export def SYS_writev: u64			= 20;
export def SYS_access: u64			= 21;
export def SYS_pipe: u64			= 22;
export def SYS_select: u64			= 23;
export def SYS_sched_yield: u64			= 24;
export def SYS_mremap: u64			= 25;
export def SYS_msync: u64			= 26;
export def SYS_mincore: u64			= 27;
export def SYS_madvise: u64			= 28;
export def SYS_shmget: u64			= 29;
export def SYS_shmat: u64			= 30;
export def SYS_shmctl: u64			= 31;
export def SYS_dup: u64				= 32;
export def SYS_dup2: u64			= 33;
export def SYS_pause: u64			= 34;
export def SYS_nanosleep: u64			= 35;
export def SYS_getitimer: u64			= 36;
export def SYS_alarm: u64			= 37;
export def SYS_setitimer: u64			= 38;
export def SYS_getpid: u64			= 39;
export def SYS_sendfile: u64			= 40;
export def SYS_socket: u64			= 41;
export def SYS_connect: u64			= 42;
export def SYS_accept: u64			= 43;
export def SYS_sendto: u64			= 44;
export def SYS_recvfrom: u64			= 45;
export def SYS_sendmsg: u64			= 46;
export def SYS_recvmsg: u64			= 47;
export def SYS_shutdown: u64			= 48;
export def SYS_bind: u64			= 49;
export def SYS_listen: u64			= 50;
export def SYS_getsockname: u64			= 51;
export def SYS_getpeername: u64			= 52;
export def SYS_socketpair: u64			= 53;
export def SYS_setsockopt: u64			= 54;
export def SYS_getsockopt: u64			= 55;
export def SYS_clone: u64			= 56;
export def SYS_fork: u64			= 57;
export def SYS_vfork: u64			= 58;
export def SYS_execve: u64			= 59;
export def SYS_exit: u64			= 60;
export def SYS_wait4: u64			= 61;
export def SYS_kill: u64			= 62;
export def SYS_uname: u64			= 63;
export def SYS_semget: u64			= 64;
export def SYS_semop: u64			= 65;
export def SYS_semctl: u64			= 66;
export def SYS_shmdt: u64			= 67;
export def SYS_msgget: u64			= 68;
export def SYS_msgsnd: u64			= 69;
export def SYS_msgrcv: u64			= 70;
export def SYS_msgctl: u64			= 71;
export def SYS_fcntl: u64			= 72;
export def SYS_flock: u64			= 73;
export def SYS_fsync: u64			= 74;
export def SYS_fdatasync: u64			= 75;
export def SYS_truncate: u64			= 76;
export def SYS_ftruncate: u64			= 77;
export def SYS_getdents: u64			= 78;
export def SYS_getcwd: u64			= 79;
export def SYS_chdir: u64			= 80;
export def SYS_fchdir: u64			= 81;
export def SYS_rename: u64			= 82;
export def SYS_mkdir: u64			= 83;
export def SYS_rmdir: u64			= 84;
export def SYS_creat: u64			= 85;
export def SYS_link: u64			= 86;
export def SYS_unlink: u64			= 87;
export def SYS_symlink: u64			= 88;
export def SYS_readlink: u64			= 89;
export def SYS_chmod: u64			= 90;
export def SYS_fchmod: u64			= 91;
export def SYS_chown: u64			= 92;
export def SYS_fchown: u64			= 93;
export def SYS_lchown: u64			= 94;
export def SYS_umask: u64			= 95;
export def SYS_gettimeofday: u64		= 96;
export def SYS_getrlimit: u64			= 97;
export def SYS_getrusage: u64			= 98;
export def SYS_sysinfo: u64			= 99;
export def SYS_times: u64			= 100;
export def SYS_ptrace: u64			= 101;
export def SYS_getuid: u64			= 102;
export def SYS_syslog: u64			= 103;
export def SYS_getgid: u64			= 104;
export def SYS_setuid: u64			= 105;
export def SYS_setgid: u64			= 106;
export def SYS_geteuid: u64			= 107;
export def SYS_getegid: u64			= 108;
export def SYS_setpgid: u64			= 109;
export def SYS_getppid: u64			= 110;
export def SYS_getpgrp: u64			= 111;
export def SYS_setsid: u64			= 112;
export def SYS_setreuid: u64			= 113;
export def SYS_setregid: u64			= 114;
export def SYS_getgroups: u64			= 115;
export def SYS_setgroups: u64			= 116;
export def SYS_setresuid: u64			= 117;
export def SYS_getresuid: u64			= 118;
export def SYS_setresgid: u64			= 119;
export def SYS_getresgid: u64			= 120;
export def SYS_getpgid: u64			= 121;
export def SYS_setfsuid: u64			= 122;
export def SYS_setfsgid: u64			= 123;
export def SYS_getsid: u64			= 124;
export def SYS_capget: u64			= 125;
export def SYS_capset: u64			= 126;
export def SYS_rt_sigpending: u64		= 127;
export def SYS_rt_sigtimedwait: u64		= 128;
export def SYS_rt_sigqueueinfo: u64		= 129;
export def SYS_rt_sigsuspend: u64		= 130;
export def SYS_sigaltstack: u64			= 131;
export def SYS_utime: u64			= 132;
export def SYS_mknod: u64			= 133;
export def SYS_uselib: u64			= 134;
export def SYS_personality: u64			= 135;
export def SYS_ustat: u64			= 136;
export def SYS_statfs: u64			= 137;
export def SYS_fstatfs: u64			= 138;
export def SYS_sysfs: u64			= 139;
export def SYS_getpriority: u64			= 140;
export def SYS_setpriority: u64			= 141;
export def SYS_sched_setparam: u64		= 142;
export def SYS_sched_getparam: u64		= 143;
export def SYS_sched_setscheduler: u64		= 144;
export def SYS_sched_getscheduler: u64		= 145;
export def SYS_sched_get_priority_max: u64	= 146;
export def SYS_sched_get_priority_min: u64	= 147;
export def SYS_sched_rr_get_interval: u64	= 148;
export def SYS_mlock: u64			= 149;
export def SYS_munlock: u64			= 150;
export def SYS_mlockall: u64			= 151;
export def SYS_munlockall: u64			= 152;
export def SYS_vhangup: u64			= 153;
export def SYS_modify_ldt: u64			= 154;
export def SYS_pivot_root: u64			= 155;
export def SYS__sysctl: u64			= 156;
export def SYS_prctl: u64			= 157;
export def SYS_arch_prctl: u64			= 158;
export def SYS_adjtimex: u64			= 159;
export def SYS_setrlimit: u64			= 160;
export def SYS_chroot: u64			= 161;
export def SYS_sync: u64			= 162;
export def SYS_acct: u64			= 163;
export def SYS_settimeofday: u64		= 164;
export def SYS_mount: u64			= 165;
export def SYS_umount2: u64			= 166;
export def SYS_swapon: u64			= 167;
export def SYS_swapoff: u64			= 168;
export def SYS_reboot: u64			= 169;
export def SYS_sethostname: u64			= 170;
export def SYS_setdomainname: u64		= 171;
export def SYS_iopl: u64			= 172;
export def SYS_ioperm: u64			= 173;
export def SYS_create_module: u64		= 174;
export def SYS_init_module: u64			= 175;
export def SYS_delete_module: u64		= 176;
export def SYS_get_kernel_syms: u64		= 177;
export def SYS_query_module: u64		= 178;
export def SYS_quotactl: u64			= 179;
export def SYS_nfsservctl: u64			= 180;
export def SYS_getpmsg: u64			= 181;
export def SYS_putpmsg: u64			= 182;
export def SYS_afs_syscall: u64			= 183;
export def SYS_tuxcall: u64			= 184;
export def SYS_security: u64			= 185;
export def SYS_gettid: u64			= 186;
export def SYS_readahead: u64			= 187;
export def SYS_setxattr: u64			= 188;
export def SYS_lsetxattr: u64			= 189;
export def SYS_fsetxattr: u64			= 190;
export def SYS_getxattr: u64			= 191;
export def SYS_lgetxattr: u64			= 192;
export def SYS_fgetxattr: u64			= 193;
export def SYS_listxattr: u64			= 194;
export def SYS_llistxattr: u64			= 195;
export def SYS_flistxattr: u64			= 196;
export def SYS_removexattr: u64			= 197;
export def SYS_lremovexattr: u64		= 198;
export def SYS_fremovexattr: u64		= 199;
export def SYS_tkill: u64			= 200;
export def SYS_time: u64			= 201;
export def SYS_futex: u64			= 202;
export def SYS_sched_setaffinity: u64		= 203;
export def SYS_sched_getaffinity: u64		= 204;
export def SYS_set_thread_area: u64		= 205;
export def SYS_io_setup: u64			= 206;
export def SYS_io_destroy: u64			= 207;
export def SYS_io_getevents: u64		= 208;
export def SYS_io_submit: u64			= 209;
export def SYS_io_cancel: u64			= 210;
export def SYS_get_thread_area: u64		= 211;
export def SYS_lookup_dcookie: u64		= 212;
export def SYS_epoll_create: u64		= 213;
export def SYS_epoll_ctl_old: u64		= 214;
export def SYS_epoll_wait_old: u64		= 215;
export def SYS_remap_file_pages: u64		= 216;
export def SYS_getdents64: u64			= 217;
export def SYS_set_tid_address: u64		= 218;
export def SYS_restart_syscall: u64		= 219;
export def SYS_semtimedop: u64			= 220;
export def SYS_fadvise64: u64			= 221;
export def SYS_timer_create: u64		= 222;
export def SYS_timer_settime: u64		= 223;
export def SYS_timer_gettime: u64		= 224;
export def SYS_timer_getoverrun: u64		= 225;
export def SYS_timer_delete: u64		= 226;
export def SYS_clock_settime: u64		= 227;
export def SYS_clock_gettime: u64		= 228;
export def SYS_clock_getres: u64		= 229;
export def SYS_clock_nanosleep: u64		= 230;
export def SYS_exit_group: u64			= 231;
export def SYS_epoll_wait: u64			= 232;
export def SYS_epoll_ctl: u64			= 233;
export def SYS_tgkill: u64			= 234;
export def SYS_utimes: u64			= 235;
export def SYS_vserver: u64			= 236;
export def SYS_mbind: u64			= 237;
export def SYS_set_mempolicy: u64		= 238;
export def SYS_get_mempolicy: u64		= 239;
export def SYS_mq_open: u64			= 240;
export def SYS_mq_unlink: u64			= 241;
export def SYS_mq_timedsend: u64		= 242;
export def SYS_mq_timedreceive: u64		= 243;
export def SYS_mq_notify: u64			= 244;
export def SYS_mq_getsetattr: u64		= 245;
export def SYS_kexec_load: u64			= 246;
export def SYS_waitid: u64			= 247;
export def SYS_add_key: u64			= 248;
export def SYS_request_key: u64			= 249;
export def SYS_keyctl: u64			= 250;
export def SYS_ioprio_set: u64			= 251;
export def SYS_ioprio_get: u64			= 252;
export def SYS_inotify_init: u64		= 253;
export def SYS_inotify_add_watch: u64		= 254;
export def SYS_inotify_rm_watch: u64		= 255;
export def SYS_migrate_pages: u64		= 256;
export def SYS_openat: u64			= 257;
export def SYS_mkdirat: u64			= 258;
export def SYS_mknodat: u64			= 259;
export def SYS_fchownat: u64			= 260;
export def SYS_futimesat: u64			= 261;
export def SYS_newfstatat: u64			= 262;
export def SYS_unlinkat: u64			= 263;
export def SYS_renameat: u64			= 264;
export def SYS_linkat: u64			= 265;
export def SYS_symlinkat: u64			= 266;
export def SYS_readlinkat: u64			= 267;
export def SYS_fchmodat: u64			= 268;
export def SYS_faccessat: u64			= 269;
export def SYS_pselect6: u64			= 270;
export def SYS_ppoll: u64			= 271;
export def SYS_unshare: u64			= 272;
export def SYS_set_robust_list: u64		= 273;
export def SYS_get_robust_list: u64		= 274;
export def SYS_splice: u64			= 275;
export def SYS_tee: u64				= 276;
export def SYS_sync_file_range: u64		= 277;
export def SYS_vmsplice: u64			= 278;
export def SYS_move_pages: u64			= 279;
export def SYS_utimensat: u64			= 280;
export def SYS_epoll_pwait: u64			= 281;
export def SYS_signalfd: u64			= 282;
export def SYS_timerfd_create: u64		= 283;
export def SYS_eventfd: u64			= 284;
export def SYS_fallocate: u64			= 285;
export def SYS_timerfd_settime: u64		= 286;
export def SYS_timerfd_gettime: u64		= 287;
export def SYS_accept4: u64			= 288;
export def SYS_signalfd4: u64			= 289;
export def SYS_eventfd2: u64			= 290;
export def SYS_epoll_create1: u64		= 291;
export def SYS_dup3: u64			= 292;
export def SYS_pipe2: u64			= 293;
export def SYS_inotify_init1: u64		= 294;
export def SYS_preadv: u64			= 295;
export def SYS_pwritev: u64			= 296;
export def SYS_rt_tgsigqueueinfo: u64		= 297;
export def SYS_perf_event_open: u64		= 298;
export def SYS_recvmmsg: u64			= 299;
export def SYS_fanotify_init: u64		= 300;
export def SYS_fanotify_mark: u64		= 301;
export def SYS_prlimit64: u64			= 302;
export def SYS_name_to_handle_at: u64		= 303;
export def SYS_open_by_handle_at: u64		= 304;
export def SYS_clock_adjtime: u64		= 305;
export def SYS_syncfs: u64			= 306;
export def SYS_sendmmsg: u64			= 307;
export def SYS_setns: u64			= 308;
export def SYS_getcpu: u64			= 309;
export def SYS_process_vm_readv: u64		= 310;
export def SYS_process_vm_writev: u64		= 311;
export def SYS_kcmp: u64			= 312;
export def SYS_finit_module: u64		= 313;
export def SYS_sched_setattr: u64		= 314;
export def SYS_sched_getattr: u64		= 315;
export def SYS_renameat2: u64			= 316;
export def SYS_seccomp: u64			= 317;
export def SYS_getrandom: u64			= 318;
export def SYS_memfd_create: u64		= 319;
export def SYS_kexec_file_load: u64		= 320;
export def SYS_bpf: u64				= 321;
export def SYS_execveat: u64			= 322;
export def SYS_userfaultfd: u64			= 323;
export def SYS_membarrier: u64			= 324;
export def SYS_mlock2: u64			= 325;
export def SYS_copy_file_range: u64		= 326;
export def SYS_preadv2: u64			= 327;
export def SYS_pwritev2: u64			= 328;
export def SYS_pkey_mprotect: u64		= 329;
export def SYS_pkey_alloc: u64			= 330;
export def SYS_pkey_free: u64			= 331;
export def SYS_statx: u64			= 332;
export def SYS_io_pgetevents: u64		= 333;
export def SYS_rseq: u64			= 334;
export def SYS_pidfd_send_signal: u64		= 424;
export def SYS_io_uring_setup: u64		= 425;
export def SYS_io_uring_enter: u64		= 426;
export def SYS_io_uring_register: u64		= 427;
export def SYS_open_tree: u64			= 428;
export def SYS_move_mount: u64			= 429;
export def SYS_fsopen: u64			= 430;
export def SYS_fsconfig: u64			= 431;
export def SYS_fsmount: u64			= 432;
export def SYS_fspick: u64			= 433;
0707010000003A000081A4000000000000000000000001654939DE00000FCE000000000000000000000000000000000000002F00000000harec-1699297758.b4dd427/rt/+linux/syscalls.hafn syscall0(u64) u64;
fn syscall1(u64, u64) u64;
fn syscall2(u64, u64, u64) u64;
fn syscall3(u64, u64, u64, u64) u64;
fn syscall4(u64, u64, u64, u64, u64) u64;
fn syscall5(u64, u64, u64, u64, u64, u64) u64;
fn syscall6(u64, u64, u64, u64, u64, u64, u64) u64;

export fn write(fd: int, buf: *const opaque, count: size) size =
	syscall3(SYS_write, fd: u64, buf: uintptr: u64, count: u64): size;

export fn close(fd: int) int = syscall1(SYS_close, fd: u64): int;

export fn dup3(old: int, new: int, flags: int) int =
	syscall3(SYS_dup3, old: u64, new: u64, flags: u64): int;

export fn dup2(old: int, new: int) int =
	syscall3(SYS_dup3, old: u64, new: u64, 0): int;

export fn getpid() int = syscall0(SYS_getpid): int;

export def EXIT_SUCCESS: int = 0;
export def EXIT_FAILURE: int = 1;

export fn exit(status: int) never = {
	syscall1(SYS_exit, status: u64);
	abort();
};

export fn fork() int = syscall2(SYS_clone, SIGCHLD: u64, 0u64): int;

export fn execve(
	path: *const u8,
	argv: *[*]nullable *const u8,
	envp: *[*]nullable *const u8,
) int = syscall3(SYS_execve,
	path: uintptr: u64,
	argv: uintptr: u64,
	envp: uintptr: u64): int;

export fn wait4(pid: int, status: *int, options: int, rusage: nullable *opaque) void = {
	syscall4(SYS_wait4, pid: u64, status: uintptr: u64,
		options: u64, rusage: uintptr: u64);
};

export fn wifexited(status: int) bool = wtermsig(status) == 0;
export fn wexitstatus(status: int) int = (status & 0xff00) >> 8;

export fn wtermsig(status: int) int = status & 0x7f;
export fn wifsignaled(status: int) bool = (status & 0xffff) - 1 < 0xff;

export fn kill(pid: int, signal: int) int =
	syscall2(SYS_kill, pid: u64, signal: u64): int;

export fn pipe2(pipefd: *[2]int, flags: int) int =
	syscall2(SYS_pipe2, pipefd: uintptr: u64, flags: u64): int;

export def MAP_SHARED: uint		= 0x01;
export def MAP_PRIVATE: uint		= 0x02;
export def MAP_SHARED_VALIDATE: uint	= 0x03;
export def MAP_FIXED: uint		= 0x10;
export def MAP_ANON: uint		= 0x20;
export def MAP_NORESERVE: uint		= 0x4000;
export def MAP_GROWSDOWN: uint		= 0x0100;
export def MAP_DENYWRITE: uint		= 0x0800;
export def MAP_EXECUTABLE: uint		= 0x1000;
export def MAP_LOCKED: uint		= 0x2000;
export def MAP_POPULATE: uint		= 0x8000;
export def MAP_NONBLOCK: uint		= 0x10000;
export def MAP_STACK: uint		= 0x20000;
export def MAP_HUGETLB: uint		= 0x40000;
export def MAP_SYNC: uint		= 0x80000;
export def MAP_FIXED_NOREPLACE: uint	= 0x100000;
export def MAP_FILE: uint		= 0;
export def MAP_HUGE_SHIFT: uint		= 26;
export def MAP_HUGE_MASK: uint		= 0x3f;
export def MAP_HUGE_64KB: uint		= 16 << 26;
export def MAP_HUGE_512KB: uint		= 19 << 26;
export def MAP_HUGE_1MB: uint		= 20 << 26;
export def MAP_HUGE_2MB: uint		= 21 << 26;
export def MAP_HUGE_8MB: uint		= 23 << 26;
export def MAP_HUGE_16MB: uint		= 24 << 26;
export def MAP_HUGE_32MB: uint		= 25 << 26;
export def MAP_HUGE_256MB: uint		= 28 << 26;
export def MAP_HUGE_512MB: uint		= 29 << 26;
export def MAP_HUGE_1GB: uint		= 30 << 26;
export def MAP_HUGE_2GB: uint		= 31 << 26;
export def MAP_HUGE_16GB: uint		= 34 << 26;

export def PROT_NONE: uint	= 0;
export def PROT_READ: uint 	= 1;
export def PROT_WRITE: uint	= 2;
export def PROT_EXEC: uint	= 4;
export def PROT_GROWSDOWN: uint	= 0x01000000;
export def PROT_GROWSUP: uint	= 0x02000000;

export fn mmap(
	addr: nullable *opaque,
	length: size,
	prot: uint,
	flags: uint,
	fd: int,
	offs: size
) *opaque = {
	let r = syscall6(SYS_mmap, addr: uintptr: u64, length: u64, prot: u64,
		flags: u64, fd: u64, offs: u64): u64;
	return if (r: int == -EPERM && addr == null
			&& flags & MAP_ANON > 0 && flags & MAP_FIXED == 0) {
		yield -ENOMEM: uintptr: *opaque; // Fix up incorrect EPERM from kernel
	} else r: uintptr: *opaque;
};

export fn munmap(addr: *opaque, length: size) int =
	syscall2(SYS_munmap, addr: uintptr: u64, length: u64): int;

export fn mprotect(addr: *opaque, length: size, prot: uint) int =
	syscall3(SYS_mprotect, addr: uintptr: u64, length: u64, prot: u64): int;

export def SIGABRT: int	= 6;
export def SIGCHLD: int	= 17;
0707010000003B000041ED000000000000000000000002654939DE00000000000000000000000000000000000000000000002400000000harec-1699297758.b4dd427/rt/+netbsd0707010000003C000081A4000000000000000000000001654939DE00000BBA000000000000000000000000000000000000002D00000000harec-1699297758.b4dd427/rt/+netbsd/errno.haexport def EPERM: int = 1;
export def ENOENT: int = 2;
export def ESRCH: int = 3;
export def EINTR: int = 4;
export def EIO: int = 5;
export def ENXIO: int = 6;
export def E2BIG: int = 7;
export def ENOEXEC: int = 8;
export def EBADF: int = 9;
export def ECHILD: int = 10;
export def EDEADLK: int = 11;
export def ENOMEM: int = 12;
export def EACCES: int = 13;
export def EFAULT: int = 14;
export def ENOTBLK: int = 15;
export def EBUSY: int = 16;
export def EEXIST: int = 17;
export def EXDEV: int = 18;
export def ENODEV: int = 19;
export def ENOTDIR: int = 20;
export def EISDIR: int = 21;
export def EINVAL: int = 22;
export def ENFILE: int = 23;
export def EMFILE: int = 24;
export def ENOTTY: int = 25;
export def ETXTBSY: int = 26;
export def EFBIG: int = 27;
export def ENOSPC: int = 28;
export def ESPIPE: int = 29;
export def EROFS: int = 30;
export def EMLINK: int = 31;
export def EPIPE: int = 32;
export def EDOM: int = 33;
export def ERANGE: int = 34;
export def EAGAIN: int = 35;
export def EWOULDBLOCK: int = EAGAIN;
export def EINPROGRESS: int = 36;
export def EALREADY: int = 37;
export def ENOTSOCK: int = 38;
export def EDESTADDRREQ: int = 39;
export def EMSGSIZE: int = 40;
export def EPROTOTYPE: int = 41;
export def ENOPROTOOPT: int = 42;
export def EPROTONOSUPPORT: int = 43;
export def ESOCKTNOSUPPORT: int = 44;
export def EOPNOTSUPP: int = 45;
export def EPFNOSUPPORT: int = 46;
export def EAFNOSUPPORT: int = 47;
export def EADDRINUSE: int = 48;
export def EADDRNOTAVAIL: int = 49;
export def ENETDOWN: int = 50;
export def ENETUNREACH: int = 51;
export def ENETRESET: int = 52;
export def ECONNABORTED: int = 53;
export def ECONNRESET: int = 54;
export def ENOBUFS: int = 55;
export def EISCONN: int = 56;
export def ENOTCONN: int = 57;
export def ESHUTDOWN: int = 58;
export def ETOOMANYREFS: int = 59;
export def ETIMEDOUT: int = 60;
export def ECONNREFUSED: int = 61;
export def ELOOP: int = 62;
export def ENAMETOOLONG: int = 63;
export def EHOSTDOWN: int = 64;
export def EHOSTUNREACH: int = 65;
export def ENOTEMPTY: int = 66;
export def EPROCLIM: int = 67;
export def EUSERS: int = 68;
export def EDQUOT: int = 69;
export def ESTALE: int = 70;
export def EREMOTE: int = 71;
export def EBADRPC: int = 72;
export def ERPCMISMATCH: int = 73;
export def EPROGUNAVAIL: int = 74;
export def EPROGMISMATCH: int = 75;
export def EPROCUNAVAIL: int = 76;
export def ENOLCK: int = 77;
export def ENOSYS: int = 78;
export def EFTYPE: int = 79;
export def EAUTH: int = 80;
export def ENEEDAUTH: int = 81;
export def EIDRM: int = 82;
export def ENOMSG: int = 83;
export def EOVERFLOW: int = 84;
export def EILSEQ: int = 85;
export def ENOTSUP: int = 86;
export def ECANCELED: int = 87;
export def EBADMSG: int = 88;
export def ENODATA: int = 89;
export def ENOSR: int = 90;
export def ENOSTR: int = 91;
export def ETIME: int = 92;
export def ENOATTR: int = 93;
export def EMULTIHOP: int = 94;
export def ENOLINK: int = 95;
export def EPROTO: int = 96;
export def ELAST: int = 96;
0707010000003D000081A4000000000000000000000001654939DE00000139000000000000000000000000000000000000003100000000harec-1699297758.b4dd427/rt/+netbsd/segmalloc.ha// Allocates a segment.
fn segmalloc(n: size) nullable *opaque = {
	let p: *opaque = mmap(null, n,
		PROT_READ | PROT_WRITE,
		MAP_PRIVATE | MAP_ANON, -1, 0);
	return if (p: uintptr: int == -ENOMEM) null else p;
};

// Frees a segment allocated with segmalloc.
fn segfree(p: *opaque, s: size) int = munmap(p, s);
0707010000003E000081A4000000000000000000000001654939DE00000103000000000000000000000000000000000000003300000000harec-1699297758.b4dd427/rt/+netbsd/start+x86_64.s.section ".note.netbsd.ident", "a"
	.long   2f-1f
	.long   4f-3f
	.long   1
1:      .asciz "NetBSD"
2:      .p2align 2
3:      .long   199905
4:      .p2align 2

.text
.global _start
_start:
	xor %rbp, %rbp
	movq %rsp, %rdi
	andq $-16, %rsp
	call rt.start_ha
0707010000003F000081A4000000000000000000000001654939DE000003E3000000000000000000000000000000000000003500000000harec-1699297758.b4dd427/rt/+netbsd/syscall+x86_64.s.section .text.rt.syscall0
.global rt.syscall0
rt.syscall0:
	movq %rdi, %rax
	syscall
	ret

.section .text.rt.syscall1
.global rt.syscall1
rt.syscall1:
	movq %rdi, %rax
	movq %rsi, %rdi
	syscall
	ret

.section .text.rt.syscall2
.global rt.syscall2
rt.syscall2:
	movq %rdi, %rax
	movq %rsi, %rdi
	movq %rdx, %rsi
	syscall
	ret

.section .text.rt.syscall3
.global rt.syscall3
rt.syscall3:
	movq %rdi, %rax
	movq %rsi, %rdi
	movq %rdx, %rsi
	movq %rcx, %rdx
	syscall
	ret

.section .text.rt.syscall4
.global rt.syscall4
rt.syscall4:
	movq %rdi, %rax
	movq %r8, %r10
	movq %rsi, %rdi
	movq %rdx, %rsi
	movq %rcx, %rdx
	syscall
	ret

.section .text.rt.syscall5
.global rt.syscall5
rt.syscall5:
	movq %rdi, %rax
	movq %r8, %r10
	movq %rsi, %rdi
	movq %r9, %r8
	movq %rdx, %rsi
	movq %rcx, %rdx
	syscall
	ret

.section .text.rt.syscall6
.global rt.syscall6
rt.syscall6:
	movq %rdi, %rax
	movq %r8, %r10
	movq %rsi, %rdi
	movq %r9, %r8
	movq %rdx, %rsi
	movq 8(%rsp), %r9
	movq %rcx, %rdx
	syscall
	ret
07070100000040000081A4000000000000000000000001654939DE00004291000000000000000000000000000000000000003100000000harec-1699297758.b4dd427/rt/+netbsd/syscallno.haexport def SYS_syscall: u64 = 0;
export def SYS_exit: u64 = 1;
export def SYS_fork: u64 = 2;
export def SYS_read: u64 = 3;
export def SYS_write: u64 = 4;
export def SYS_open: u64 = 5;
export def SYS_close: u64 = 6;
export def SYS_compat_50_wait4: u64 = 7;
export def SYS_compat_43_ocreat: u64 = 8;
export def SYS_link: u64 = 9;
export def SYS_unlink: u64 = 10;
export def SYS_chdir: u64 = 12;
export def SYS_fchdir: u64 = 13;
export def SYS_compat_50_mknod: u64 = 14;
export def SYS_chmod: u64 = 15;
export def SYS_chown: u64 = 16;
export def SYS_break: u64 = 17;
export def SYS_compat_20_getfsstat: u64 = 18;
export def SYS_compat_43_olseek: u64 = 19;
export def SYS_getpid: u64 = 20;
export def SYS_compat_40_mount: u64 = 21;
export def SYS_unmount: u64 = 22;
export def SYS_setuid: u64 = 23;
export def SYS_getuid: u64 = 24;
export def SYS_geteuid: u64 = 25;
export def SYS_ptrace: u64 = 26;
export def SYS_recvmsg: u64 = 27;
export def SYS_sendmsg: u64 = 28;
export def SYS_recvfrom: u64 = 29;
export def SYS_accept: u64 = 30;
export def SYS_getpeername: u64 = 31;
export def SYS_getsockname: u64 = 32;
export def SYS_access: u64 = 33;
export def SYS_chflags: u64 = 34;
export def SYS_fchflags: u64 = 35;
export def SYS_sync: u64 = 36;
export def SYS_kill: u64 = 37;
export def SYS_compat_43_stat43: u64 = 38;
export def SYS_getppid: u64 = 39;
export def SYS_compat_43_lstat43: u64 = 40;
export def SYS_dup: u64 = 41;
export def SYS_pipe: u64 = 42;
export def SYS_getegid: u64 = 43;
export def SYS_profil: u64 = 44;
export def SYS_ktrace: u64 = 45;
export def SYS_compat_13_sigaction13: u64 = 46;
export def SYS_getgid: u64 = 47;
export def SYS_compat_13_sigprocmask13: u64 = 48;
export def SYS___getlogin: u64 = 49;
export def SYS___setlogin: u64 = 50;
export def SYS_acct: u64 = 51;
export def SYS_compat_13_sigpending13: u64 = 52;
export def SYS_compat_13_sigaltstack13: u64 = 53;
export def SYS_ioctl: u64 = 54;
export def SYS_compat_12_oreboot: u64 = 55;
export def SYS_revoke: u64 = 56;
export def SYS_symlink: u64 = 57;
export def SYS_readlink: u64 = 58;
export def SYS_execve: u64 = 59;
export def SYS_umask: u64 = 60;
export def SYS_chroot: u64 = 61;
export def SYS_compat_43_fstat43: u64 = 62;
export def SYS_compat_43_ogetkerninfo: u64 = 63;
export def SYS_compat_43_ogetpagesize: u64 = 64;
export def SYS_compat_12_msync: u64 = 65;
export def SYS_vfork: u64 = 66;
export def SYS_compat_43_ommap: u64 = 71;
export def SYS_vadvise: u64 = 72;
export def SYS_munmap: u64 = 73;
export def SYS_mprotect: u64 = 74;
export def SYS_madvise: u64 = 75;
export def SYS_mincore: u64 = 78;
export def SYS_getgroups: u64 = 79;
export def SYS_setgroups: u64 = 80;
export def SYS_getpgrp: u64 = 81;
export def SYS_setpgid: u64 = 82;
export def SYS_compat_50_setitimer: u64 = 83;
export def SYS_compat_43_owait: u64 = 84;
export def SYS_compat_12_oswapon: u64 = 85;
export def SYS_compat_50_getitimer: u64 = 86;
export def SYS_compat_43_ogethostname: u64 = 87;
export def SYS_compat_43_osethostname: u64 = 88;
export def SYS_compat_43_ogetdtablesize: u64 = 89;
export def SYS_dup2: u64 = 90;
export def SYS_fcntl: u64 = 92;
export def SYS_compat_50_select: u64 = 93;
export def SYS_fsync: u64 = 95;
export def SYS_setpriority: u64 = 96;
export def SYS_compat_30_socket: u64 = 97;
export def SYS_connect: u64 = 98;
export def SYS_compat_43_oaccept: u64 = 99;
export def SYS_getpriority: u64 = 100;
export def SYS_compat_43_osend: u64 = 101;
export def SYS_compat_43_orecv: u64 = 102;
export def SYS_compat_13_sigreturn13: u64 = 103;
export def SYS_bind: u64 = 104;
export def SYS_setsockopt: u64 = 105;
export def SYS_listen: u64 = 106;
export def SYS_compat_43_osigvec: u64 = 108;
export def SYS_compat_43_osigblock: u64 = 109;
export def SYS_compat_43_osigsetmask: u64 = 110;
export def SYS_compat_13_sigsuspend13: u64 = 111;
export def SYS_compat_43_osigstack: u64 = 112;
export def SYS_compat_43_orecvmsg: u64 = 113;
export def SYS_compat_43_osendmsg: u64 = 114;
export def SYS_compat_50_gettimeofday: u64 = 116;
export def SYS_compat_50_getrusage: u64 = 117;
export def SYS_getsockopt: u64 = 118;
export def SYS_readv: u64 = 120;
export def SYS_writev: u64 = 121;
export def SYS_compat_50_settimeofday: u64 = 122;
export def SYS_fchown: u64 = 123;
export def SYS_fchmod: u64 = 124;
export def SYS_compat_43_orecvfrom: u64 = 125;
export def SYS_setreuid: u64 = 126;
export def SYS_setregid: u64 = 127;
export def SYS_rename: u64 = 128;
export def SYS_compat_43_otruncate: u64 = 129;
export def SYS_compat_43_oftruncate: u64 = 130;
export def SYS_flock: u64 = 131;
export def SYS_mkfifo: u64 = 132;
export def SYS_sendto: u64 = 133;
export def SYS_shutdown: u64 = 134;
export def SYS_socketpair: u64 = 135;
export def SYS_mkdir: u64 = 136;
export def SYS_rmdir: u64 = 137;
export def SYS_compat_50_utimes: u64 = 138;
export def SYS_compat_50_adjtime: u64 = 140;
export def SYS_compat_43_ogetpeername: u64 = 141;
export def SYS_compat_43_ogethostid: u64 = 142;
export def SYS_compat_43_osethostid: u64 = 143;
export def SYS_compat_43_ogetrlimit: u64 = 144;
export def SYS_compat_43_osetrlimit: u64 = 145;
export def SYS_compat_43_okillpg: u64 = 146;
export def SYS_setsid: u64 = 147;
export def SYS_compat_50_quotactl: u64 = 148;
export def SYS_compat_43_oquota: u64 = 149;
export def SYS_compat_43_ogetsockname: u64 = 150;
export def SYS_nfssvc: u64 = 155;
export def SYS_compat_43_ogetdirentries: u64 = 156;
export def SYS_compat_20_statfs: u64 = 157;
export def SYS_compat_20_fstatfs: u64 = 158;
export def SYS_compat_30_getfh: u64 = 161;
export def SYS_compat_09_ogetdomainname: u64 = 162;
export def SYS_compat_09_osetdomainname: u64 = 163;
export def SYS_compat_09_ouname: u64 = 164;
export def SYS_sysarch: u64 = 165;
export def SYS_compat_10_osemsys: u64 = 169;
export def SYS_compat_10_omsgsys: u64 = 170;
export def SYS_compat_10_oshmsys: u64 = 171;
export def SYS_pread: u64 = 173;
export def SYS_pwrite: u64 = 174;
export def SYS_compat_30_ntp_gettime: u64 = 175;
export def SYS_ntp_adjtime: u64 = 176;
export def SYS_setgid: u64 = 181;
export def SYS_setegid: u64 = 182;
export def SYS_seteuid: u64 = 183;
export def SYS_lfs_bmapv: u64 = 184;
export def SYS_lfs_markv: u64 = 185;
export def SYS_lfs_segclean: u64 = 186;
export def SYS_compat_50_lfs_segwait: u64 = 187;
export def SYS_compat_12_stat12: u64 = 188;
export def SYS_compat_12_fstat12: u64 = 189;
export def SYS_compat_12_lstat12: u64 = 190;
export def SYS_pathconf: u64 = 191;
export def SYS_fpathconf: u64 = 192;
export def SYS_getsockopt2: u64 = 193;
export def SYS_getrlimit: u64 = 194;
export def SYS_setrlimit: u64 = 195;
export def SYS_compat_12_getdirentries: u64 = 196;
export def SYS_mmap: u64 = 197;
export def SYS___syscall: u64 = 198;
export def SYS_lseek: u64 = 199;
export def SYS_truncate: u64 = 200;
export def SYS_ftruncate: u64 = 201;
export def SYS___sysctl: u64 = 202;
export def SYS_mlock: u64 = 203;
export def SYS_munlock: u64 = 204;
export def SYS_undelete: u64 = 205;
export def SYS_compat_50_futimes: u64 = 206;
export def SYS_getpgid: u64 = 207;
export def SYS_reboot: u64 = 208;
export def SYS_poll: u64 = 209;
export def SYS_afssys: u64 = 210;
export def SYS_compat_14___semctl: u64 = 220;
export def SYS_semget: u64 = 221;
export def SYS_semop: u64 = 222;
export def SYS_semconfig: u64 = 223;
export def SYS_compat_14_msgctl: u64 = 224;
export def SYS_msgget: u64 = 225;
export def SYS_msgsnd: u64 = 226;
export def SYS_msgrcv: u64 = 227;
export def SYS_shmat: u64 = 228;
export def SYS_compat_14_shmctl: u64 = 229;
export def SYS_shmdt: u64 = 230;
export def SYS_shmget: u64 = 231;
export def SYS_compat_50_clock_gettime: u64 = 232;
export def SYS_compat_50_clock_settime: u64 = 233;
export def SYS_compat_50_clock_getres: u64 = 234;
export def SYS_timer_create: u64 = 235;
export def SYS_timer_delete: u64 = 236;
export def SYS_compat_50_timer_settime: u64 = 237;
export def SYS_compat_50_timer_gettime: u64 = 238;
export def SYS_timer_getoverrun: u64 = 239;
export def SYS_compat_50_nanosleep: u64 = 240;
export def SYS_fdatasync: u64 = 241;
export def SYS_mlockall: u64 = 242;
export def SYS_munlockall: u64 = 243;
export def SYS_compat_50___sigtimedwait: u64 = 244;
export def SYS_sigqueueinfo: u64 = 245;
export def SYS_modctl: u64 = 246;
export def SYS__ksem_init: u64 = 247;
export def SYS__ksem_open: u64 = 248;
export def SYS__ksem_unlink: u64 = 249;
export def SYS__ksem_close: u64 = 250;
export def SYS__ksem_post: u64 = 251;
export def SYS__ksem_wait: u64 = 252;
export def SYS__ksem_trywait: u64 = 253;
export def SYS__ksem_getvalue: u64 = 254;
export def SYS__ksem_destroy: u64 = 255;
export def SYS__ksem_timedwait: u64 = 256;
export def SYS_mq_open: u64 = 257;
export def SYS_mq_close: u64 = 258;
export def SYS_mq_unlink: u64 = 259;
export def SYS_mq_getattr: u64 = 260;
export def SYS_mq_setattr: u64 = 261;
export def SYS_mq_notify: u64 = 262;
export def SYS_mq_send: u64 = 263;
export def SYS_mq_receive: u64 = 264;
export def SYS_compat_50_mq_timedsend: u64 = 265;
export def SYS_compat_50_mq_timedreceive: u64 = 266;
export def SYS___posix_rename: u64 = 270;
export def SYS_swapctl: u64 = 271;
export def SYS_compat_30_getdents: u64 = 272;
export def SYS_minherit: u64 = 273;
export def SYS_lchmod: u64 = 274;
export def SYS_lchown: u64 = 275;
export def SYS_compat_50_lutimes: u64 = 276;
export def SYS___msync13: u64 = 277;
export def SYS_compat_30___stat13: u64 = 278;
export def SYS_compat_30___fstat13: u64 = 279;
export def SYS_compat_30___lstat13: u64 = 280;
export def SYS___sigaltstack14: u64 = 281;
export def SYS___vfork14: u64 = 282;
export def SYS___posix_chown: u64 = 283;
export def SYS___posix_fchown: u64 = 284;
export def SYS___posix_lchown: u64 = 285;
export def SYS_getsid: u64 = 286;
export def SYS___clone: u64 = 287;
export def SYS_fktrace: u64 = 288;
export def SYS_preadv: u64 = 289;
export def SYS_pwritev: u64 = 290;
export def SYS_compat_16___sigaction14: u64 = 291;
export def SYS___sigpending14: u64 = 292;
export def SYS___sigprocmask14: u64 = 293;
export def SYS___sigsuspend14: u64 = 294;
export def SYS_compat_16___sigreturn14: u64 = 295;
export def SYS___getcwd: u64 = 296;
export def SYS_fchroot: u64 = 297;
export def SYS_compat_30_fhopen: u64 = 298;
export def SYS_compat_30_fhstat: u64 = 299;
export def SYS_compat_20_fhstatfs: u64 = 300;
export def SYS_compat_50_____semctl13: u64 = 301;
export def SYS_compat_50___msgctl13: u64 = 302;
export def SYS_compat_50___shmctl13: u64 = 303;
export def SYS_lchflags: u64 = 304;
export def SYS_issetugid: u64 = 305;
export def SYS_utrace: u64 = 306;
export def SYS_getcontext: u64 = 307;
export def SYS_setcontext: u64 = 308;
export def SYS__lwp_create: u64 = 309;
export def SYS__lwp_exit: u64 = 310;
export def SYS__lwp_self: u64 = 311;
export def SYS__lwp_wait: u64 = 312;
export def SYS__lwp_suspend: u64 = 313;
export def SYS__lwp_continue: u64 = 314;
export def SYS__lwp_wakeup: u64 = 315;
export def SYS__lwp_getprivate: u64 = 316;
export def SYS__lwp_setprivate: u64 = 317;
export def SYS__lwp_kill: u64 = 318;
export def SYS__lwp_detach: u64 = 319;
export def SYS_compat_50__lwp_park: u64 = 320;
export def SYS__lwp_unpark: u64 = 321;
export def SYS__lwp_unpark_all: u64 = 322;
export def SYS__lwp_setname: u64 = 323;
export def SYS__lwp_getname: u64 = 324;
export def SYS__lwp_ctl: u64 = 325;
export def SYS_compat_60_sa_register: u64 = 330;
export def SYS_compat_60_sa_stacks: u64 = 331;
export def SYS_compat_60_sa_enable: u64 = 332;
export def SYS_compat_60_sa_setconcurrency: u64 = 333;
export def SYS_compat_60_sa_yield: u64 = 334;
export def SYS_compat_60_sa_preempt: u64 = 335;
export def SYS___sigaction_sigtramp: u64 = 340;
export def SYS_rasctl: u64 = 343;
export def SYS_kqueue: u64 = 344;
export def SYS_compat_50_kevent: u64 = 345;
export def SYS__sched_setparam: u64 = 346;
export def SYS__sched_getparam: u64 = 347;
export def SYS__sched_setaffinity: u64 = 348;
export def SYS__sched_getaffinity: u64 = 349;
export def SYS_sched_yield: u64 = 350;
export def SYS__sched_protect: u64 = 351;
export def SYS_fsync_range: u64 = 354;
export def SYS_uuidgen: u64 = 355;
export def SYS_getvfsstat: u64 = 356;
export def SYS_statvfs1: u64 = 357;
export def SYS_fstatvfs1: u64 = 358;
export def SYS_compat_30_fhstatvfs1: u64 = 359;
export def SYS_extattrctl: u64 = 360;
export def SYS_extattr_set_file: u64 = 361;
export def SYS_extattr_get_file: u64 = 362;
export def SYS_extattr_delete_file: u64 = 363;
export def SYS_extattr_set_fd: u64 = 364;
export def SYS_extattr_get_fd: u64 = 365;
export def SYS_extattr_delete_fd: u64 = 366;
export def SYS_extattr_set_link: u64 = 367;
export def SYS_extattr_get_link: u64 = 368;
export def SYS_extattr_delete_link: u64 = 369;
export def SYS_extattr_list_fd: u64 = 370;
export def SYS_extattr_list_file: u64 = 371;
export def SYS_extattr_list_link: u64 = 372;
export def SYS_compat_50_pselect: u64 = 373;
export def SYS_compat_50_pollts: u64 = 374;
export def SYS_setxattr: u64 = 375;
export def SYS_lsetxattr: u64 = 376;
export def SYS_fsetxattr: u64 = 377;
export def SYS_getxattr: u64 = 378;
export def SYS_lgetxattr: u64 = 379;
export def SYS_fgetxattr: u64 = 380;
export def SYS_listxattr: u64 = 381;
export def SYS_llistxattr: u64 = 382;
export def SYS_flistxattr: u64 = 383;
export def SYS_removexattr: u64 = 384;
export def SYS_lremovexattr: u64 = 385;
export def SYS_fremovexattr: u64 = 386;
export def SYS_compat_50___stat30: u64 = 387;
export def SYS_compat_50___fstat30: u64 = 388;
export def SYS_compat_50___lstat30: u64 = 389;
export def SYS___getdents30: u64 = 390;
export def SYS_compat_30___fhstat30: u64 = 392;
export def SYS_compat_50___ntp_gettime30: u64 = 393;
export def SYS___socket30: u64 = 394;
export def SYS___getfh30: u64 = 395;
export def SYS___fhopen40: u64 = 396;
export def SYS___fhstatvfs140: u64 = 397;
export def SYS_compat_50___fhstat40: u64 = 398;
export def SYS_aio_cancel: u64 = 399;
export def SYS_aio_error: u64 = 400;
export def SYS_aio_fsync: u64 = 401;
export def SYS_aio_read: u64 = 402;
export def SYS_aio_return: u64 = 403;
export def SYS_compat_50_aio_suspend: u64 = 404;
export def SYS_aio_write: u64 = 405;
export def SYS_lio_listio: u64 = 406;
export def SYS___mount50: u64 = 410;
export def SYS_mremap: u64 = 411;
export def SYS_pset_create: u64 = 412;
export def SYS_pset_destroy: u64 = 413;
export def SYS_pset_assign: u64 = 414;
export def SYS__pset_bind: u64 = 415;
export def SYS___posix_fadvise50: u64 = 416;
export def SYS___select50: u64 = 417;
export def SYS___gettimeofday50: u64 = 418;
export def SYS___settimeofday50: u64 = 419;
export def SYS___utimes50: u64 = 420;
export def SYS___adjtime50: u64 = 421;
export def SYS___lfs_segwait50: u64 = 422;
export def SYS___futimes50: u64 = 423;
export def SYS___lutimes50: u64 = 424;
export def SYS___setitimer50: u64 = 425;
export def SYS___getitimer50: u64 = 426;
export def SYS___clock_gettime50: u64 = 427;
export def SYS___clock_settime50: u64 = 428;
export def SYS___clock_getres50: u64 = 429;
export def SYS___nanosleep50: u64 = 430;
export def SYS_____sigtimedwait50: u64 = 431;
export def SYS___mq_timedsend50: u64 = 432;
export def SYS___mq_timedreceive50: u64 = 433;
export def SYS_compat_60__lwp_park: u64 = 434;
export def SYS___kevent50: u64 = 435;
export def SYS___pselect50: u64 = 436;
export def SYS___pollts50: u64 = 437;
export def SYS___aio_suspend50: u64 = 438;
export def SYS___stat50: u64 = 439;
export def SYS___fstat50: u64 = 440;
export def SYS___lstat50: u64 = 441;
export def SYS_____semctl50: u64 = 442;
export def SYS___shmctl50: u64 = 443;
export def SYS___msgctl50: u64 = 444;
export def SYS___getrusage50: u64 = 445;
export def SYS___timer_settime50: u64 = 446;
export def SYS___timer_gettime50: u64 = 447;
export def SYS___ntp_gettime50: u64 = 448;
export def SYS___wait450: u64 = 449;
export def SYS___mknod50: u64 = 450;
export def SYS___fhstat50: u64 = 451;
export def SYS_pipe2: u64 = 453;
export def SYS_dup3: u64 = 454;
export def SYS_kqueue1: u64 = 455;
export def SYS_paccept: u64 = 456;
export def SYS_linkat: u64 = 457;
export def SYS_renameat: u64 = 458;
export def SYS_mkfifoat: u64 = 459;
export def SYS_mknodat: u64 = 460;
export def SYS_mkdirat: u64 = 461;
export def SYS_faccessat: u64 = 462;
export def SYS_fchmodat: u64 = 463;
export def SYS_fchownat: u64 = 464;
export def SYS_fexecve: u64 = 465;
export def SYS_fstatat: u64 = 466;
export def SYS_utimensat: u64 = 467;
export def SYS_openat: u64 = 468;
export def SYS_readlinkat: u64 = 469;
export def SYS_symlinkat: u64 = 470;
export def SYS_unlinkat: u64 = 471;
export def SYS_futimens: u64 = 472;
export def SYS___quotactl: u64 = 473;
export def SYS_posix_spawn: u64 = 474;
export def SYS_recvmmsg: u64 = 475;
export def SYS_sendmmsg: u64 = 476;
export def SYS_clock_nanosleep: u64 = 477;
export def SYS____lwp_park60: u64 = 478;
export def SYS_posix_fallocate: u64 = 479;
export def SYS_fdiscard: u64 = 480;
export def SYS_wait6: u64 = 481;
export def SYS_clock_getcpuclockid2: u64 = 482;
export def SYS_MAXSYSCALL: u64 = 483;
export def SYS_NSYSENT: u64 = 512;
07070100000041000081A4000000000000000000000001654939DE00000A1D000000000000000000000000000000000000003000000000harec-1699297758.b4dd427/rt/+netbsd/syscalls.hafn syscall0(u64) u64;
fn syscall1(u64, u64) u64;
fn syscall2(u64, u64, u64) u64;
fn syscall3(u64, u64, u64, u64) u64;
fn syscall4(u64, u64, u64, u64, u64) u64;
fn syscall5(u64, u64, u64, u64, u64, u64) u64;
fn syscall6(u64, u64, u64, u64, u64, u64, u64) u64;

export fn write(fd: int, buf: *const opaque, count: size) size =
	syscall3(SYS_write, fd: u64, buf: uintptr: u64, count: u64): size;

export fn close(fd: int) int = syscall1(SYS_close, fd: u64): int;

export fn dup2(old: int, new: int) int =
	syscall2(SYS_dup2, old: u64, new: u64): int;

export fn getpid() int = syscall0(SYS_getpid): int;

export def EXIT_SUCCESS: int = 0;
export def EXIT_FAILURE: int = 1;

export fn exit(status: int) never = {
	syscall1(SYS_exit, status: u64);
	abort();
};

export fn fork() int = syscall0(SYS_fork): int;

export fn execve(
	path: *const u8,
	argv: *[*]nullable *const u8,
	envp: *[*]nullable *const u8,
) int = syscall3(SYS_execve,
	path: uintptr: u64,
	argv: uintptr: u64,
	envp: uintptr: u64): int;

export fn wait4(pid: int, status: *int, options: int, rusage: nullable *opaque) void = {
	syscall4(SYS_compat_50_wait4, pid: u64, status: uintptr: u64,
		options: u64, rusage: uintptr: u64);
};

export fn wifexited(status: int) bool = wtermsig(status) == 0;
export fn wexitstatus(status: int) int = (status & 0xff00) >> 8;

export fn wtermsig(status: int) int = status & 0x7f;
export fn wifsignaled(status: int) bool =
	wtermsig(status) != 0o177 && wtermsig(status) != 0 && status != 0x13;

export fn kill(pid: int, signal: int) int =
	syscall2(SYS_kill, pid: u64, signal: u64): int;

export fn pipe2(pipefd: *[2]int, flags: int) int =
	syscall2(SYS_pipe2, pipefd: uintptr: u64, flags: u64): int;

export def MAP_SHARED: uint = 0x0001;
export def MAP_PRIVATE: uint = 0x0002;
export def MAP_FIXED: uint = 0x0010;
export def __MAP_NOREPLACE: uint = 0x0800;
export def MAP_ANON: uint = 0x1000;
export def MAP_ANONYMOUS: uint = MAP_ANON;
export def __MAP_NOFAULT: uint = 0x2000;
export def MAP_STACK: uint = 0x4000;
export def MAP_CONCEAL: uint = 0x8000;

def PROT_NONE: uint = 0x00;
def PROT_READ: uint = 0x01;
def PROT_WRITE: uint = 0x02;
def PROT_EXEC: uint = 0x04;

export fn munmap(addr: *opaque, length: size) int =
	syscall2(SYS_munmap, addr: uintptr: u64, length: u64): int;

export def SIGABRT: int	= 6;
export def SIGCHLD: int	= 20;
07070100000042000041ED000000000000000000000002654939DE00000000000000000000000000000000000000000000002500000000harec-1699297758.b4dd427/rt/+openbsd07070100000043000081A4000000000000000000000001654939DE00000BAF000000000000000000000000000000000000002E00000000harec-1699297758.b4dd427/rt/+openbsd/errno.haexport def EPERM: int = 1;
export def ENOENT: int = 2;
export def ESRCH: int = 3;
export def EINTR: int = 4;
export def EIO: int = 5;
export def ENXIO: int = 6;
export def E2BIG: int = 7;
export def ENOEXEC: int = 8;
export def EBADF: int = 9;
export def ECHILD: int = 10;
export def EDEADLK: int = 11;
export def ENOMEM: int = 12;
export def EACCES: int = 13;
export def EFAULT: int = 14;
export def ENOTBLK: int = 15;
export def EBUSY: int = 16;
export def EEXIST: int = 17;
export def EXDEV: int = 18;
export def ENODEV: int = 19;
export def ENOTDIR: int = 20;
export def EISDIR: int = 21;
export def EINVAL: int = 22;
export def ENFILE: int = 23;
export def EMFILE: int = 24;
export def ENOTTY: int = 25;
export def ETXTBSY: int = 26;
export def EFBIG: int = 27;
export def ENOSPC: int = 28;
export def ESPIPE: int = 29;
export def EROFS: int = 30;
export def EMLINK: int = 31;
export def EPIPE: int = 32;
export def EDOM: int = 33;
export def ERANGE: int = 34;
export def EAGAIN: int = 35;
export def EWOULDBLOCK: int = EAGAIN;
export def EINPROGRESS: int = 36;
export def EALREADY: int = 37;
export def ENOTSOCK: int = 38;
export def EDESTADDRREQ: int = 39;
export def EMSGSIZE: int = 40;
export def EPROTOTYPE: int = 41;
export def ENOPROTOOPT: int = 42;
export def EPROTONOSUPPORT: int = 43;
export def ESOCKTNOSUPPORT: int = 44;
export def EOPNOTSUPP: int = 45;
export def EPFNOSUPPORT: int = 46;
export def EAFNOSUPPORT: int = 47;
export def EADDRINUSE: int = 48;
export def EADDRNOTAVAIL: int = 49;
export def ENETDOWN: int = 50;
export def ENETUNREACH: int = 51;
export def ENETRESET: int = 52;
export def ECONNABORTED: int = 53;
export def ECONNRESET: int = 54;
export def ENOBUFS: int = 55;
export def EISCONN: int = 56;
export def ENOTCONN: int = 57;
export def ESHUTDOWN: int = 58;
export def ETOOMANYREFS: int = 59;
export def ETIMEDOUT: int = 60;
export def ECONNREFUSED: int = 61;
export def ELOOP: int = 62;
export def ENAMETOOLONG: int = 63;
export def EHOSTDOWN: int = 64;
export def EHOSTUNREACH: int = 65;
export def ENOTEMPTY: int = 66;
export def EPROCLIM: int = 67;
export def EUSERS: int = 68;
export def EDQUOT: int = 69;
export def ESTALE: int = 70;
export def EREMOTE: int = 71;
export def EBADRPC: int = 72;
export def ERPCMISMATCH: int = 73;
export def EPROGUNAVAIL: int = 74;
export def EPROGMISMATCH: int = 75;
export def EPROCUNAVAIL: int = 76;
export def ENOLCK: int = 77;
export def ENOSYS: int = 78;
export def EFTYPE: int = 79;
export def EAUTH: int = 80;
export def ENEEDAUTH: int = 81;
export def EIPSEC: int = 82;
export def ENOATTR: int = 83;
export def EILSEQ: int = 84;
export def ENOMEDIUM: int = 85;
export def EMEDIUMTYPE: int = 86;
export def EOVERFLOW: int = 87;
export def ECANCELED: int = 88;
export def EIDRM: int = 89;
export def ENOMSG: int = 90;
export def ENOTSUP: int = 91;
export def EBADMSG: int = 92;
export def ENOTRECOVERABLE: int = 93;
export def EOWNERDEAD: int = 94;
export def EPROTO: int = 95;
export def ELAST: int = 95;
07070100000044000081A4000000000000000000000001654939DE00000139000000000000000000000000000000000000003200000000harec-1699297758.b4dd427/rt/+openbsd/segmalloc.ha// Allocates a segment.
fn segmalloc(n: size) nullable *opaque = {
	let p: *opaque = mmap(null, n,
		PROT_READ | PROT_WRITE,
		MAP_PRIVATE | MAP_ANON, -1, 0);
	return if (p: uintptr: int == -ENOMEM) null else p;
};

// Frees a segment allocated with segmalloc.
fn segfree(p: *opaque, s: size) int = munmap(p, s);
07070100000045000081A4000000000000000000000001654939DE00000076000000000000000000000000000000000000003500000000harec-1699297758.b4dd427/rt/+openbsd/start+aarch64.s.text
.global _start
_start:
	mov x29, #0
	mov x30, #0
	mov x0, sp
	add sp, x0, #-16
	and sp, sp, #-16
	b rt.start_ha
07070100000046000081A4000000000000000000000001654939DE0000004C000000000000000000000000000000000000003500000000harec-1699297758.b4dd427/rt/+openbsd/start+riscv64.s.text
.global _start
_start:
	mv a0, sp
	andi sp, sp, -16
	tail rt.start_ha
07070100000047000081A4000000000000000000000001654939DE000000DC000000000000000000000000000000000000003400000000harec-1699297758.b4dd427/rt/+openbsd/start+x86_64.s	.section ".note.openbsd.ident", "a"
	.p2align 2
	.long	0x8
	.long	0x4
	.long	0x1
	.asciz	"OpenBSD"
	.long	0x0
	.previous

.text
.global _start
_start:
	xor %rbp, %rbp
	movq %rsp, %rdi
	andq $-16, %rsp
	call rt.start_ha
07070100000048000081A4000000000000000000000001654939DE0000034E000000000000000000000000000000000000003700000000harec-1699297758.b4dd427/rt/+openbsd/syscall+aarch64.s.section .text.rt.syscall0
.global rt.syscall0
rt.syscall0:
	mov x8, x0
	svc 0
	ret

.section .text.rt.syscall1
.global rt.syscall1
rt.syscall1:
	mov x8, x0
	mov x0, x1
	svc 0
	ret

.section .text.rt.syscall2
.global rt.syscall2
rt.syscall2:
	mov x8, x0
	mov x0, x1
	mov x1, x2
	svc 0
	ret

.section .text.rt.syscall3
.global rt.syscall3
rt.syscall3:
	mov x8, x0
	mov x0, x1
	mov x1, x2
	mov x2, x3
	svc 0
	ret

.section .text.rt.syscall4
.global rt.syscall4
rt.syscall4:
	mov x8, x0
	mov x0, x1
	mov x1, x2
	mov x2, x3
	mov x3, x4
	svc 0
	ret

.section .text.rt.syscall5
.global rt.syscall5
rt.syscall5:
	mov x8, x0
	mov x0, x1
	mov x1, x2
	mov x2, x3
	mov x3, x4
	mov x4, x5
	svc 0
	ret

.section .text.rt.syscall6
.global rt.syscall6
rt.syscall6:
	mov x8, x0
	mov x0, x1
	mov x1, x2
	mov x2, x3
	mov x3, x4
	mov x4, x5
	mov x5, x6
	svc 0
	ret
07070100000049000081A4000000000000000000000001654939DE00000332000000000000000000000000000000000000003700000000harec-1699297758.b4dd427/rt/+openbsd/syscall+riscv64.s.section .text.rt.syscall0
.global rt.syscall0
rt.syscall0:
	mv a7, a0
	ecall
	ret

.section .text.rt.syscall1
.global rt.syscall1
rt.syscall1:
	mv a7, a0
	mv a0, a1
	ecall
	ret

.section .text.rt.syscall2
.global rt.syscall2
rt.syscall2:
	mv a7, a0
	mv a0, a1
	mv a1, a2
	ecall
	ret

.section .text.rt.syscall3
.global rt.syscall3
rt.syscall3:
	mv a7, a0
	mv a0, a1
	mv a1, a2
	mv a2, a3
	ecall
	ret

.section .text.rt.syscall4
.global rt.syscall4
rt.syscall4:
	mv a7, a0
	mv a0, a1
	mv a1, a2
	mv a2, a3
	mv a3, a4
	ecall
	ret

.section .text.rt.syscall5
.global rt.syscall5
rt.syscall5:
	mv a7, a0
	mv a0, a1
	mv a1, a2
	mv a2, a3
	mv a3, a4
	mv a4, a5
	ecall
	ret

.section .text.rt.syscall6
.global rt.syscall6
rt.syscall6:
	mv a7, a0
	mv a0, a1
	mv a1, a2
	mv a2, a3
	mv a3, a4
	mv a4, a5
	mv a5, a6
	ecall
	ret
0707010000004A000081A4000000000000000000000001654939DE000003E3000000000000000000000000000000000000003600000000harec-1699297758.b4dd427/rt/+openbsd/syscall+x86_64.s.section .text.rt.syscall0
.global rt.syscall0
rt.syscall0:
	movq %rdi, %rax
	syscall
	ret