packages feed

symantic-parser 0.2.0.20210703 → 0.2.1.20210803

raw patch · 310 files changed

+23695/−17707 lines, 310 filesdep ~symantic-basePVP ok

version bump matches the API change (PVP)

Dependency ranges changed: symantic-base

API changes (from Hackage documentation)

Files

Hacking.md view
@@ -8,6 +8,13 @@ make benchmarks/repl ``` +```bash+make ghcid+make parsers/ghcid+make tests/ghcid+make benchmarks/ghcid+```+ ## Testing ```bash make tests@@ -21,7 +28,11 @@  ## Benchmarking -### Profiling+```bash+make benchmarks b=Brainfuck/ByteString/hanoi/'*' BENCHMARK_OPTIONS=-n1+```++## Profiling  #### Time ```bash
+ LICENSES/AGPL-3.0-or-later.txt view
@@ -0,0 +1,235 @@+GNU AFFERO GENERAL PUBLIC LICENSE+Version 3, 19 November 2007++Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>++Everyone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed.++                            Preamble++The GNU Affero General Public License is a free, copyleft license for software and other kinds of works, specifically designed to ensure cooperation with the community in the case of network server software.++The licenses for most software and other practical works are designed to take away your freedom to share and change the works.  By contrast, our General Public Licenses are intended to guarantee your freedom to share and change all versions of a program--to make sure it remains free software for all its users.++When we speak of free software, we are referring to freedom, not price.  Our General Public Licenses are designed to make sure that you have the freedom to distribute copies of free software (and charge for them if you wish), that you receive source code or can get it if you want it, that you can change the software or use pieces of it in new free programs, and that you know you can do these things.++Developers that use our General Public Licenses protect your rights with two steps: (1) assert copyright on the software, and (2) offer you this License which gives you legal permission to copy, distribute and/or modify the software.++A secondary benefit of defending all users' freedom is that improvements made in alternate versions of the program, if they receive widespread use, become available for other developers to incorporate.  Many developers of free software are heartened and encouraged by the resulting cooperation.  However, in the case of software used on network servers, this result may fail to come about. The GNU General Public License permits making a modified version and letting the public access it on a server without ever releasing its source code to the public.++The GNU Affero General Public License is designed specifically to ensure that, in such cases, the modified source code becomes available to the community.  It requires the operator of a network server to provide the source code of the modified version running there to the users of that server.  Therefore, public use of a modified version, on a publicly accessible server, gives the public access to the source code of the modified version.++An older license, called the Affero General Public License and published by Affero, was designed to accomplish similar goals.  This is a different license, not a version of the Affero GPL, but Affero has released a new version of the Affero GPL which permits relicensing under this license.++The precise terms and conditions for copying, distribution and modification follow.++                       TERMS AND CONDITIONS++0. Definitions.++"This License" refers to version 3 of the GNU Affero General Public License.++"Copyright" also means copyright-like laws that apply to other kinds of works, such as semiconductor masks.++"The Program" refers to any copyrightable work licensed under this License.  Each licensee is addressed as "you".  "Licensees" and "recipients" may be individuals or organizations.++To "modify" a work means to copy from or adapt all or part of the work in a fashion requiring copyright permission, other than the making of an exact copy.  The resulting work is called a "modified version" of the earlier work or a work "based on" the earlier work.++A "covered work" means either the unmodified Program or a work based on the Program.++To "propagate" a work means to do anything with it that, without permission, would make you directly or secondarily liable for infringement under applicable copyright law, except executing it on a computer or modifying a private copy.  Propagation includes copying, distribution (with or without modification), making available to the public, and in some countries other activities as well.++To "convey" a work means any kind of propagation that enables other parties to make or receive copies.  Mere interaction with a user through a computer network, with no transfer of a copy, is not conveying.++An interactive user interface displays "Appropriate Legal Notices" to the extent that it includes a convenient and prominently visible feature that (1) displays an appropriate copyright notice, and (2) tells the user that there is no warranty for the work (except to the extent that warranties are provided), that licensees may convey the work under this License, and how to view a copy of this License.  If the interface presents a list of user commands or options, such as a menu, a prominent item in the list meets this criterion.++1. Source Code.+The "source code" for a work means the preferred form of the work for making modifications to it.  "Object code" means any non-source form of a work.++A "Standard Interface" means an interface that either is an official standard defined by a recognized standards body, or, in the case of interfaces specified for a particular programming language, one that is widely used among developers working in that language.++The "System Libraries" of an executable work include anything, other than the work as a whole, that (a) is included in the normal form of packaging a Major Component, but which is not part of that Major Component, and (b) serves only to enable use of the work with that Major Component, or to implement a Standard Interface for which an implementation is available to the public in source code form.  A "Major Component", in this context, means a major essential component (kernel, window system, and so on) of the specific operating system (if any) on which the executable work runs, or a compiler used to produce the work, or an object code interpreter used to run it.++The "Corresponding Source" for a work in object code form means all the source code needed to generate, install, and (for an executable work) run the object code and to modify the work, including scripts to control those activities.  However, it does not include the work's System Libraries, or general-purpose tools or generally available free programs which are used unmodified in performing those activities but which are not part of the work.  For example, Corresponding Source includes interface definition files associated with source files for the work, and the source code for shared libraries and dynamically linked subprograms that the work is specifically designed to require, such as by intimate data communication or control flow between those+subprograms and other parts of the work.++The Corresponding Source need not include anything that users can regenerate automatically from other parts of the Corresponding Source.++The Corresponding Source for a work in source code form is that same work.++2. Basic Permissions.+All rights granted under this License are granted for the term of copyright on the Program, and are irrevocable provided the stated conditions are met.  This License explicitly affirms your unlimited permission to run the unmodified Program.  The output from running a covered work is covered by this License only if the output, given its content, constitutes a covered work.  This License acknowledges your rights of fair use or other equivalent, as provided by copyright law.++You may make, run and propagate covered works that you do not convey, without conditions so long as your license otherwise remains in force.  You may convey covered works to others for the sole purpose of having them make modifications exclusively for you, or provide you with facilities for running those works, provided that you comply with the terms of this License in conveying all material for which you do not control copyright.  Those thus making or running the covered works for you must do so exclusively on your behalf, under your direction and control, on terms that prohibit them from making any copies of your copyrighted material outside their relationship with you.++Conveying under any other circumstances is permitted solely under the conditions stated below.  Sublicensing is not allowed; section 10 makes it unnecessary.++3. Protecting Users' Legal Rights From Anti-Circumvention Law.+No covered work shall be deemed part of an effective technological measure under any applicable law fulfilling obligations under article 11 of the WIPO copyright treaty adopted on 20 December 1996, or similar laws prohibiting or restricting circumvention of such measures.++When you convey a covered work, you waive any legal power to forbid circumvention of technological measures to the extent such circumvention is effected by exercising rights under this License with respect to the covered work, and you disclaim any intention to limit operation or modification of the work as a means of enforcing, against the work's users, your or third parties' legal rights to forbid circumvention of technological measures.++4. Conveying Verbatim Copies.+You may convey verbatim copies of the Program's source code as you receive it, in any medium, provided that you conspicuously and appropriately publish on each copy an appropriate copyright notice; keep intact all notices stating that this License and any non-permissive terms added in accord with section 7 apply to the code; keep intact all notices of the absence of any warranty; and give all recipients a copy of this License along with the Program.++You may charge any price or no price for each copy that you convey, and you may offer support or warranty protection for a fee.++5. Conveying Modified Source Versions.+You may convey a work based on the Program, or the modifications to produce it from the Program, in the form of source code under the terms of section 4, provided that you also meet all of these conditions:++    a) The work must carry prominent notices stating that you modified it, and giving a relevant date.++    b) The work must carry prominent notices stating that it is released under this License and any conditions added under section 7.  This requirement modifies the requirement in section 4 to "keep intact all notices".++    c) You must license the entire work, as a whole, under this License to anyone who comes into possession of a copy.  This License will therefore apply, along with any applicable section 7 additional terms, to the whole of the work, and all its parts, regardless of how they are packaged.  This License gives no permission to license the work in any other way, but it does not invalidate such permission if you have separately received it.++    d) If the work has interactive user interfaces, each must display Appropriate Legal Notices; however, if the Program has interactive interfaces that do not display Appropriate Legal Notices, your work need not make them do so.++A compilation of a covered work with other separate and independent works, which are not by their nature extensions of the covered work, and which are not combined with it such as to form a larger program, in or on a volume of a storage or distribution medium, is called an "aggregate" if the compilation and its resulting copyright are not used to limit the access or legal rights of the compilation's users beyond what the individual works permit.  Inclusion of a covered work in an aggregate does not cause this License to apply to the other parts of the aggregate.++6. Conveying Non-Source Forms.+You may convey a covered work in object code form under the terms of sections 4 and 5, provided that you also convey the machine-readable Corresponding Source under the terms of this License, in one of these ways:++    a) Convey the object code in, or embodied in, a physical product (including a physical distribution medium), accompanied by the Corresponding Source fixed on a durable physical medium customarily used for software interchange.++    b) Convey the object code in, or embodied in, a physical product (including a physical distribution medium), accompanied by a written offer, valid for at least three years and valid for as long as you offer spare parts or customer support for that product model, to give anyone who possesses the object code either (1) a copy of the Corresponding Source for all the software in the product that is covered by this License, on a durable physical medium customarily used for software interchange, for a price no more than your reasonable cost of physically performing this conveying of source, or (2) access to copy the Corresponding Source from a network server at no charge.++    c) Convey individual copies of the object code with a copy of the written offer to provide the Corresponding Source.  This alternative is allowed only occasionally and noncommercially, and only if you received the object code with such an offer, in accord with subsection 6b.++    d) Convey the object code by offering access from a designated place (gratis or for a charge), and offer equivalent access to the Corresponding Source in the same way through the same place at no further charge.  You need not require recipients to copy the Corresponding Source along with the object code.  If the place to copy the object code is a network server, the Corresponding Source may be on a different server (operated by you or a third party) that supports equivalent copying facilities, provided you maintain clear directions next to the object code saying where to find the Corresponding Source.  Regardless of what server hosts the Corresponding Source, you remain obligated to ensure that it is available for as long as needed to satisfy these requirements.++    e) Convey the object code using peer-to-peer transmission, provided you inform other peers where the object code and Corresponding Source of the work are being offered to the general public at no charge under subsection 6d.++A separable portion of the object code, whose source code is excluded from the Corresponding Source as a System Library, need not be included in conveying the object code work.++A "User Product" is either (1) a "consumer product", which means any tangible personal property which is normally used for personal, family, or household purposes, or (2) anything designed or sold for incorporation into a dwelling.  In determining whether a product is a consumer product, doubtful cases shall be resolved in favor of coverage.  For a particular product received by a particular user, "normally used" refers to a typical or common use of that class of product, regardless of the status of the particular user or of the way in which the particular user actually uses, or expects or is expected to use, the product.  A product is a consumer product regardless of whether the product has substantial commercial, industrial or non-consumer uses, unless such uses represent the only significant mode of use of the product.++"Installation Information" for a User Product means any methods, procedures, authorization keys, or other information required to install and execute modified versions of a covered work in that User Product from a modified version of its Corresponding Source.  The information must suffice to ensure that the continued functioning of the modified object code is in no case prevented or interfered with solely because modification has been made.++If you convey an object code work under this section in, or with, or specifically for use in, a User Product, and the conveying occurs as part of a transaction in which the right of possession and use of the User Product is transferred to the recipient in perpetuity or for a fixed term (regardless of how the transaction is characterized), the Corresponding Source conveyed under this section must be accompanied by the Installation Information.  But this requirement does not apply if neither you nor any third party retains the ability to install modified object code on the User Product (for example, the work has been installed in ROM).++The requirement to provide Installation Information does not include a requirement to continue to provide support service, warranty, or updates for a work that has been modified or installed by the recipient, or for the User Product in which it has been modified or installed.  Access to a network may be denied when the modification itself materially and adversely affects the operation of the network or violates the rules and protocols for communication across the network.++Corresponding Source conveyed, and Installation Information provided, in accord with this section must be in a format that is publicly documented (and with an implementation available to the public in source code form), and must require no special password or key for unpacking, reading or copying.++7. Additional Terms.+"Additional permissions" are terms that supplement the terms of this License by making exceptions from one or more of its conditions. Additional permissions that are applicable to the entire Program shall be treated as though they were included in this License, to the extent that they are valid under applicable law.  If additional permissions apply only to part of the Program, that part may be used separately under those permissions, but the entire Program remains governed by this License without regard to the additional permissions.++When you convey a copy of a covered work, you may at your option remove any additional permissions from that copy, or from any part of it.  (Additional permissions may be written to require their own removal in certain cases when you modify the work.)  You may place additional permissions on material, added by you to a covered work, for which you have or can give appropriate copyright permission.++Notwithstanding any other provision of this License, for material you add to a covered work, you may (if authorized by the copyright holders of that material) supplement the terms of this License with terms:++    a) Disclaiming warranty or limiting liability differently from the terms of sections 15 and 16 of this License; or++    b) Requiring preservation of specified reasonable legal notices or author attributions in that material or in the Appropriate Legal Notices displayed by works containing it; or++    c) Prohibiting misrepresentation of the origin of that material, or requiring that modified versions of such material be marked in reasonable ways as different from the original version; or++    d) Limiting the use for publicity purposes of names of licensors or authors of the material; or++    e) Declining to grant rights under trademark law for use of some trade names, trademarks, or service marks; or++    f) Requiring indemnification of licensors and authors of that material by anyone who conveys the material (or modified versions of it) with contractual assumptions of liability to the recipient, for any liability that these contractual assumptions directly impose on those licensors and authors.++All other non-permissive additional terms are considered "further restrictions" within the meaning of section 10.  If the Program as you received it, or any part of it, contains a notice stating that it is governed by this License along with a term that is a further restriction, you may remove that term.  If a license document contains a further restriction but permits relicensing or conveying under this License, you may add to a covered work material governed by the terms of that license document, provided that the further restriction does not survive such relicensing or conveying.++If you add terms to a covered work in accord with this section, you must place, in the relevant source files, a statement of the additional terms that apply to those files, or a notice indicating where to find the applicable terms.++Additional terms, permissive or non-permissive, may be stated in the form of a separately written license, or stated as exceptions; the above requirements apply either way.++8. Termination.++You may not propagate or modify a covered work except as expressly provided under this License.  Any attempt otherwise to propagate or modify it is void, and will automatically terminate your rights under this License (including any patent licenses granted under the third paragraph of section 11).++However, if you cease all violation of this License, then your license from a particular copyright holder is reinstated (a) provisionally, unless and until the copyright holder explicitly and finally terminates your license, and (b) permanently, if the copyright holder fails to notify you of the violation by some reasonable means prior to 60 days after the cessation.++Moreover, your license from a particular copyright holder is reinstated permanently if the copyright holder notifies you of the violation by some reasonable means, this is the first time you have received notice of violation of this License (for any work) from that copyright holder, and you cure the violation prior to 30 days after your receipt of the notice.++Termination of your rights under this section does not terminate the licenses of parties who have received copies or rights from you under this License.  If your rights have been terminated and not permanently reinstated, you do not qualify to receive new licenses for the same material under section 10.++9. Acceptance Not Required for Having Copies.++You are not required to accept this License in order to receive or run a copy of the Program.  Ancillary propagation of a covered work occurring solely as a consequence of using peer-to-peer transmission to receive a copy likewise does not require acceptance.  However, nothing other than this License grants you permission to propagate or modify any covered work.  These actions infringe copyright if you do not accept this License.  Therefore, by modifying or propagating a covered work, you indicate your acceptance of this License to do so.++10. Automatic Licensing of Downstream Recipients.++Each time you convey a covered work, the recipient automatically receives a license from the original licensors, to run, modify and propagate that work, subject to this License.  You are not responsible for enforcing compliance by third parties with this License.++An "entity transaction" is a transaction transferring control of an organization, or substantially all assets of one, or subdividing an organization, or merging organizations.  If propagation of a covered work results from an entity transaction, each party to that transaction who receives a copy of the work also receives whatever licenses to the work the party's predecessor in interest had or could give under the previous paragraph, plus a right to possession of the Corresponding Source of the work from the predecessor in interest, if the predecessor has it or can get it with reasonable efforts.++You may not impose any further restrictions on the exercise of the rights granted or affirmed under this License.  For example, you may not impose a license fee, royalty, or other charge for exercise of rights granted under this License, and you may not initiate litigation (including a cross-claim or counterclaim in a lawsuit) alleging that any patent claim is infringed by making, using, selling, offering for sale, or importing the Program or any portion of it.++11. Patents.++A "contributor" is a copyright holder who authorizes use under this License of the Program or a work on which the Program is based.  The work thus licensed is called the contributor's "contributor version".++A contributor's "essential patent claims" are all patent claims owned or controlled by the contributor, whether already acquired or hereafter acquired, that would be infringed by some manner, permitted by this License, of making, using, or selling its contributor version, but do not include claims that would be infringed only as a consequence of further modification of the contributor version.  For purposes of this definition, "control" includes the right to grant patent sublicenses in a manner consistent with the requirements of this License.++Each contributor grants you a non-exclusive, worldwide, royalty-free patent license under the contributor's essential patent claims, to make, use, sell, offer for sale, import and otherwise run, modify and propagate the contents of its contributor version.++In the following three paragraphs, a "patent license" is any express agreement or commitment, however denominated, not to enforce a patent (such as an express permission to practice a patent or covenant not to sue for patent infringement).  To "grant" such a patent license to a party means to make such an agreement or commitment not to enforce a patent against the party.++If you convey a covered work, knowingly relying on a patent license, and the Corresponding Source of the work is not available for anyone to copy, free of charge and under the terms of this License, through a publicly available network server or other readily accessible means, then you must either (1) cause the Corresponding Source to be so available, or (2) arrange to deprive yourself of the benefit of the patent license for this particular work, or (3) arrange, in a manner consistent with the requirements of this License, to extend the patent+license to downstream recipients.  "Knowingly relying" means you have actual knowledge that, but for the patent license, your conveying the covered work in a country, or your recipient's use of the covered work in a country, would infringe one or more identifiable patents in that country that you have reason to believe are valid.++If, pursuant to or in connection with a single transaction or arrangement, you convey, or propagate by procuring conveyance of, a covered work, and grant a patent license to some of the parties receiving the covered work authorizing them to use, propagate, modify or convey a specific copy of the covered work, then the patent license you grant is automatically extended to all recipients of the covered work and works based on it.++A patent license is "discriminatory" if it does not include within the scope of its coverage, prohibits the exercise of, or is conditioned on the non-exercise of one or more of the rights that are specifically granted under this License.  You may not convey a covered work if you are a party to an arrangement with a third party that is in the business of distributing software, under which you make payment to the third party based on the extent of your activity of conveying the work, and under which the third party grants, to any of the parties who would receive the covered work from you, a discriminatory patent license (a) in connection with copies of the covered work conveyed by you (or copies made from those copies), or (b) primarily for and in connection with specific products or compilations that contain the covered work, unless you entered into that arrangement, or that patent license was granted, prior to 28 March 2007.++Nothing in this License shall be construed as excluding or limiting any implied license or other defenses to infringement that may otherwise be available to you under applicable patent law.++12. No Surrender of Others' Freedom.++If conditions are imposed on you (whether by court order, agreement or otherwise) that contradict the conditions of this License, they do not excuse you from the conditions of this License.  If you cannot convey a covered work so as to satisfy simultaneously your obligations under this License and any other pertinent obligations, then as a consequence you may+not convey it at all.  For example, if you agree to terms that obligate you to collect a royalty for further conveying from those to whom you convey the Program, the only way you could satisfy both those terms and this License would be to refrain entirely from conveying the Program.++13. Remote Network Interaction; Use with the GNU General Public License.++Notwithstanding any other provision of this License, if you modify the Program, your modified version must prominently offer all users interacting with it remotely through a computer network (if your version supports such interaction) an opportunity to receive the Corresponding Source of your version by providing access to the Corresponding Source from a network server at no charge, through some standard or customary means of facilitating copying of software.  This Corresponding Source shall include the Corresponding Source for any work covered by version 3 of the GNU General Public License that is incorporated pursuant to the following paragraph.++Notwithstanding any other provision of this License, you have permission to link or combine any covered work with a work licensed under version 3 of the GNU General Public License into a single combined work, and to convey the resulting work.  The terms of this License will continue to apply to the part which is the covered work, but the work with which it is combined will remain governed by version 3 of the GNU General Public License.++14. Revised Versions of this License.++The Free Software Foundation may publish revised and/or new versions of the GNU Affero General Public License from time to time.  Such new versions will be similar in spirit to the present version, but may differ in detail to address new problems or concerns.++Each version is given a distinguishing version number.  If the Program specifies that a certain numbered version of the GNU Affero General Public License "or any later version" applies to it, you have the option of following the terms and conditions either of that numbered version or of any later version published by the Free Software Foundation.  If the Program does not specify a version number of the GNU Affero General Public License, you may choose any version ever published by the Free Software Foundation.++If the Program specifies that a proxy can decide which future versions of the GNU Affero General Public License can be used, that proxy's public statement of acceptance of a version permanently authorizes you to choose that version for the Program.++Later license versions may give you additional or different permissions.  However, no additional obligations are imposed on any author or copyright holder as a result of your choosing to follow a later version.++15. Disclaimer of Warranty.++THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.++16. Limitation of Liability.++IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.++17. Interpretation of Sections 15 and 16.++If the disclaimer of warranty and limitation of liability provided above cannot be given local legal effect according to their terms, reviewing courts shall apply local law that most closely approximates an absolute waiver of all civil liability in connection with the Program, unless a warranty or assumption of liability accompanies a copy of the Program in return for a fee.++END OF TERMS AND CONDITIONS++            How to Apply These Terms to Your New Programs++If you develop a new program, and you want it to be of the greatest possible use to the public, the best way to achieve this is to make it free software which everyone can redistribute and change under these terms.++To do so, attach the following notices to the program.  It is safest to attach them to the start of each source file to most effectively state the exclusion of warranty; and each file should have at least the "copyright" line and a pointer to where the full notice is found.++     <one line to give the program's name and a brief idea of what it does.>+     Copyright (C) <year>  <name of author>++     This program is free software: you can redistribute it and/or modify it under the terms of the GNU Affero General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.++     This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Affero General Public License for more details.++     You should have received a copy of the GNU Affero General Public License along with this program.  If not, see <http://www.gnu.org/licenses/>.++Also add information on how to contact you by electronic and paper mail.++If your software can interact with users remotely through a computer network, you should also make sure that it provides a way for users to get its source.  For example, if your program is a web application, its interface could display a "Source" link that leads users to an archive of the code.  There are many ways you could offer source, and different solutions will be better for different programs; see section 13 for the specific requirements.++You should also get your employer (if you work as a programmer) or school, if any, to sign a "copyright disclaimer" for the program, if necessary. For more information on this, and how to apply and follow the GNU AGPL, see <http://www.gnu.org/licenses/>.
Makefile view
@@ -1,8 +1,11 @@-override RTS_OPTIONS += -L100-override TEST_OPTIONS += --color always --size-cutoff 1000000 $(addprefix -p ,$t)-override GHC_PROF_OPTIONS += -eventlog -fprof-auto -fprof-auto-calls override BENCHMARK_OPTIONS += --output benchmarks/html/$(version).html --match glob $b+override GHCID_OPTIONS += --no-height-limit --reverse-errors +override GHC_PROF_OPTIONS += -eventlog -fprof-auto -fprof-cafs+#-fprof-auto-calls override REPL_OPTIONS += -ignore-dot-ghci+override RTS_OPTIONS += -L100+override TEST_OPTIONS += --color always --size-cutoff 1000000 $(addprefix -p ,$t)+override CABAL_TEST_FLAGS += -j  cabal := $(wildcard *.cabal) package := $(notdir ./$(cabal:.cabal=))@@ -17,18 +20,18 @@ repl: 	cabal repl $(CABAL_REPL_FLAGS) $(project) ghcid:-	ghcid -c 'cabal repl $(CABAL_REPL_FLAGS) $(project) --repl-options "$(REPL_OPTIONS)"' --reverse-errors+	ghcid $(GHCID_OPTIONS) --command 'cabal repl -fno-code $(CABAL_REPL_FLAGS) $(project) $(addprefix --repl-options ,$(REPL_OPTIONS))' .PHONY: parsers parsers: 	cabal build $(CABAL_BUILD_FLAGS) $(project):parsers parsers/repl: 	cabal repl $(CABAL_REPL_FLAGS) $(project):parsers parsers/ghcid:-	ghcid -c 'cabal repl $(CABAL_REPL_FLAGS) $(project):parsers --repl-options "$(REPL_OPTIONS)"' --reverse-errors+	ghcid $(GHCID_OPTIONS) --command 'cabal repl -fno-code $(CABAL_REPL_FLAGS) $(project):parsers $(addprefix --repl-options ,$(REPL_OPTIONS))' parsers/prof-th:-	cabal v2-build lib:$(project) --enable-profiling $(GHC_PROF_OPTIONS) --write-ghc-environment-files=always+	cabal v2-build lib:$(project) --enable-profiling $(addprefix --ghc-options ,$(GHC_PROF_OPTIONS)) --write-ghc-environment-files=always 	cabal build $(CABAL_BUILD_FLAGS) $(project):parsers \-	 --enable-profiling $(GHC_PROF_OPTIONS) \+	 --enable-profiling $(addprefix --ghc-options ,$(GHC_PROF_OPTIONS)) \ 	 --ghc-options "$(addprefix -opti,+RTS $(RTS_OPTIONS))"  .PHONY: tests@@ -41,17 +44,17 @@ $(project)-test.eventlog $(project)-test.prof: 	cabal test $(CABAL_TEST_FLAGS) \ 	 --test-show-details always --test-options "$(TEST_OPTIONS) +RTS $(RTS_OPTIONS)" \-	 --enable-profiling $(GHC_PROF_OPTIONS) || true+	 --enable-profiling $(addprefix --ghc-options ,$(GHC_PROF_OPTIONS)) || true tests/prof-th:-	cabal v2-build lib:$(project) --enable-profiling $(GHC_PROF_OPTIONS) --write-ghc-environment-files=always+	cabal v2-build lib:$(project) --enable-profiling $(addprefix --ghc-options ,$(GHC_PROF_OPTIONS)) --write-ghc-environment-files=always 	cabal test $(CABAL_TEST_FLAGS) \ 	 --test-show-details always --test-options "$(TEST_OPTIONS) +RTS $(RTS_OPTIONS)" \-	 --enable-profiling $(GHC_PROF_OPTIONS) \+	 --enable-profiling $(addprefix --ghc-options ,$(GHC_PROF_OPTIONS)) \ 	 --ghc-options "$(addprefix -opti,+RTS $(RTS_OPTIONS))"-tests/repl:-	cabal repl $(CABAL_REPL_FLAGS) --enable-tests $(project)-test-tests/ghcid:-	ghcid -c 'cabal repl $(CABAL_REPL_FLAGS) $(project):tests --test-options "$(TEST_OPTIONS)"' --reverse-errors+t/repl tests/repl:+	cabal repl $(CABAL_REPL_FLAGS) $(CABAL_TEST_FLAGS) --enable-tests $(project)-test+t/ghcid tests/ghcid:+	ghcid $(GHCID_OPTIONS) --command 'cabal repl $(CABAL_REPL_FLAGS) $(CABAL_TEST_FLAGS) $(project):tests' --test ":main $(TEST_OPTIONS)"  %/accept: TEST_OPTIONS += --accept %/accept: %@@ -96,6 +99,7 @@ 	git tag -f -s -m "$(package) v$(version)" $(package)-$(version)  tar:+	reuse lint 	cabal sdist 	cabal haddock --haddock-for-hackage --enable-doc upload: LANG=C
ReadMe.md view
@@ -2,17 +2,15 @@  - Primitive grammar combinators are extensible, including the optimization pass for which they are the current top-level combinator. -- Error messages are based upon the farthest input position reached (not yet implemented in `ParsleyHaskell`) and a there is a preliminary support for error messages based upon [labeled failures](https://dl.acm.org/doi/10.1145/2851613.2851750).+- Error messages are based upon the farthest input position reached (not yet implemented in `ParsleyHaskell`) and there is a preliminary support for error messages based upon [labeled failures](https://dl.acm.org/doi/10.1145/2851613.2851750).  - Minimal input length checks ("horizon" checks) required for a successful parsing are statically computed using a [polyfix](http://okmij.org/ftp/Computation/fixed-point-combinators.html#Poly-variadic) to see beyond calls to subroutines, which is not (yet) possible in `ParsleyHaskell`. -- No dependency upon GHC plugins: `lift-plugin`, `idioms-plugin` or `parsley-garnish` for users. Those provide convenient syntaxic-sugar (by quoting an Haskell expression as itself and its `TemplateHaskell` equivalent) for writing grammar productions, but are experimental, but I do not understand them that much and do not feel confortable to maintain them in case their authors abandon them.--- No dependency upon `dependent-map` by keeping observed sharing in `def` and `ref` combinators, instead of passing by a `DMap`. And also when introducing the join-points optimization, where fresh `TemplateHaskell` names are also directly used instead of passing by a `DMap`.+- Symantics are used for grammars productions instead of GHC plugins: `lift-plugin`, `idioms-plugin` or `parsley-garnish` for users. Those provide convenient syntaxic-sugar (by quoting an Haskell expression as itself and its `TemplateHaskell` equivalent), but I do not understand them that much and do not feel confortable to maintain them in case their authors abandon them. -- No support (yet?) for general purpose registers in the `Machine` producing the `TemplateHaskell` splices. Hence `symantic-parser` generates parser much slower than `ParsleyHaskell`, comparable to `attoparsec` in the Brainfuck benchmark.+- Fresh `TemplateHaskell` names are used directly (when observing sharingm introducing join-points, etc.) instead of a detour depending upon `dependent-map`. -- License is `AGPL-3-or-later` not `BSD-3-Clause`.+- Code is a common published under the copyleft license `AGPL-3.0-or-later`, instead of the more liberal `BSD-3-Clause` of `ParsleyHaskell`.  - Testing grammars have their generated machines and `TemplateHaskell` splices followed by golden tests. @@ -29,7 +27,7 @@ and their semantics are data-types having instances of those type-classes. And the same technique is applied for machine instructions and grammar productions. -For automatic deriving, `DefaultSignatures` are supplied using automatic `trans`formations, see `Symantic.Typed.Trans`.+For automatic deriving, `DefaultSignatures` are supplied, see `Symantic.Typed.Derive`.  For pattern-matching, data-families indexed by the syntaxic type-class are supplied, see `Symantic.Typed.Data`.
ToDo.md view
@@ -1,7 +1,5 @@ - [ ] Finalize support for error messages based upon: [A Parsing Machine for Parsing Expression Grammars with Labeled Failures](https://dl.acm.org/doi/10.1145/2851613.2851750) -- [ ] Try to introduce registers like in `ParsleyHaskell`.- - [ ] Move the `Symantic.Typed.*` modules into a separate package, maybe `symantic-base`.  - [ ] Support parsing tree inputs (eg. RelaxNG in `symantic-xml` or HTTP routing in `symantic-http-server`).
benchmarks/Brainfuck.hs view
@@ -64,7 +64,6 @@  benchmark :: Benchmark benchmark = bgroup "Brainfuck" $ List.concat-  [ benchBrainfuck "helloworld"-  , benchBrainfuck "compiler"+  [ benchBrainfuck "compiler"   , benchBrainfuck "hanoi"   ]
flake.lock view
@@ -32,8 +32,8 @@     },     "nixpkgs": {       "locked": {-        "narHash": "sha256-3C35/g5bJ3KH67fOpxTkqDpfJ1CHYrO2bbl+fPgqfMQ=",-        "path": "/nix/store/6g7dgkinzm4rvwmpfp9avklsb4hiqals-nixpkgs-patched",+        "narHash": "sha256-r3EoB5BEXlDDDm6zZ571l3GQQTV+ENxis3QQF33WzrQ=",+        "path": "/nix/store/95j1q84ajdn4ry10rywngn2jhasjjzlz-nixpkgs-patched",         "type": "path"       },       "original": {@@ -56,11 +56,11 @@         ]       },       "locked": {-        "lastModified": 1626033315,-        "narHash": "sha256-vHRFhc9Bg2cxrAR9R1TSXn2f6ZwzOIMRD+0n3cXzl54=",+        "lastModified": 1627727111,+        "narHash": "sha256-y1A7iCysHlnV87HvdY06WmvqxE8kj6oGaXqD+IrCNB8=",         "ref": "master",-        "rev": "29078a0e7fbe8df3204bcf86dd902a301072574f",-        "revCount": 14,+        "rev": "eee56bd2c70439de82cbf8204080a480868f2a85",+        "revCount": 17,         "type": "git",         "url": "git://git.sourcephile.fr/haskell/symantic-base"       },
parsers/Parsers/Brainfuck/SymanticParser/Grammar.hs view
@@ -29,8 +29,8 @@   lexeme p = p SP.<* whitespace   bf :: repr [Instruction]   bf = SP.many (lexeme (SP.match (SP.look (SP.item @tok))-                               (SP.prod . coerceEnum Prelude.<$> "<>+-,.[")-                               op SP.empty))+                                 (SP.prod . coerceEnum Prelude.<$> "<>+-,.[")+                                 op SP.empty))   op :: SP.Production tok -> repr Instruction   op prod = case coerceEnum (SP.runValue prod) of     '<' -> SP.item @tok SP.$> SP.prod Backward
− parsers/Parsers/Brainfuck/inputs/helloworld.bf 
@@ -1,22 +0,0 @@-[Taken from https://esolangs.org/wiki/Brainfuck]-+++++ +++++             initialize counter (cell #0) to 10-[                       use loop to set the next four cells to 70/100/30/10-    > +++++ ++              add  7 to cell #1-    > +++++ +++++           add 10 to cell #2-    > +++                   add  3 to cell #3-    > +                     add  1 to cell #4-    <<<< -                  decrement counter (cell #0)-]-> ++ .                  print 'H'-> + .                   print 'e'-+++++ ++ .              print 'l'-.                       print 'l'-+++ .                   print 'o'-> ++ .                  print ' '-<< +++++ +++++ +++++ .  print 'W'-> .                     print 'o'-+++ .                   print 'r'------ - .               print 'l'------ --- .             print 'd'-> + .                   print '!'-> .                     print '\n'
− parsers/Parsers/Brainfuck/inputs/helloworld_golfed.bf 
@@ -1,1 +0,0 @@-++++++++++[>+++++++>++++++++++>+++>+<<<<-]>++.>+.+++++++..+++.>++.<<+++++++++++++++.>.+++.------.--------.>+.>.
parsers/Parsers/Nandlang.hs view
@@ -18,7 +18,7 @@ import qualified Data.Text as Text  import qualified Symantic.Parser as P-import qualified Symantic.Typed.Lang as Prod+import qualified Symantic.Lang as Prod  type Parser a = P.Parser Text.Text a
parsers/Parsers/Playground.hs view
@@ -3,7 +3,7 @@ module Parsers.Playground where  import Symantic.Parser-import qualified Symantic.Typed.Lang as Prod+import qualified Symantic.Lang as Prod  boom :: CombApplicable repr => repr () boom =
src/Language/Haskell/TH/HideName.hs view
@@ -1,12 +1,29 @@+{-# LANGUAGE AllowAmbiguousTypes #-} -- For hideableShow -- | This module enables to 'hideName' -- to get reproductible dumps of TemplateHaskell slices. module Language.Haskell.TH.HideName where +import Data.Bool (Bool(..))+import Data.Function (id) import Data.Functor ((<$>)) import Language.Haskell.TH import Language.Haskell.TH.Syntax import Prelude (undefined) +-- ** Type 'HideableName'+-- | Useful on golden unit tests because 'Name's+-- change often when changing unrelated source code+-- or even when changing basic GHC or executable flags.+class HideableName (showNames::Bool) where+  hideableName :: HideName a => a -> a+-- | Like 'id'.+instance HideableName 'True where+  hideableName = id+-- | Like 'hideName'.+instance HideableName 'False where+  hideableName = hideName++-- * Class 'HideName' class HideName a where   -- | Map all 'Name's to a constant in order to overcome   -- cases where resetting 'TH.counter' is not enough@@ -133,3 +150,5 @@   hideName (VarP v) = VarP (hideName v)   hideName (ViewP e p) = ViewP (hideName e) (hideName p)   hideName WildP = WildP+instance HideName a => HideName [a] where+  hideName = (hideName <$>)
src/Symantic/Parser/Grammar.hs view
@@ -8,7 +8,7 @@   , module Symantic.Parser.Grammar.Production   , module Symantic.Parser.Grammar.Write   , module Symantic.Parser.Grammar.View-  , Letable(..)+  , Referenceable(..)   , Letsable(..)   ) where import Symantic.Parser.Grammar.Combinators@@ -25,19 +25,25 @@ import Data.String (String) import Data.Typeable (Typeable) import Text.Show (Show(..))+import Language.Haskell.TH.HideName import qualified Language.Haskell.TH.Syntax as TH --- * Class 'Grammarable'+-- * Type 'Grammar'+type Grammar repr = ObserveSharing TH.Name (OptimizeGrammar repr)++-- ** Class 'Grammarable' type Grammarable tok repr =   ( CombAlternable repr   , CombApplicable repr   , CombFoldable repr-  , Letable TH.Name repr+  , Referenceable TH.Name repr   , Letsable TH.Name repr   , CombLookable repr   , CombMatchable repr   , CombSatisfiable tok repr   , CombSelectable repr+  --, CombRegisterable repr+  , CombRegisterableUnscoped repr   , Eq tok   , Ord tok   , TH.Lift tok@@ -48,18 +54,13 @@  -- | A usual pipeline to interpret 'Comb'inators: -- 'observeSharing' then 'optimizeGrammar' then a polymorphic @(repr)@.-grammar ::-  Grammarable tok repr =>-  ObserveSharing TH.Name-    (OptimizeGrammar repr) a ->-  repr a+grammar :: Grammarable tok repr => Grammar repr a -> repr a grammar = optimizeGrammar . observeSharing  -- | An usual pipeline to show 'Comb'inators: -- 'observeSharing' then 'optimizeGrammar' then 'viewGrammar' then 'show'.-showGrammar :: forall showName a tok repr.-  repr ~ ObserveSharing TH.Name (OptimizeGrammar (ViewGrammar showName)) =>-  ShowLetName showName TH.Name =>-  Grammarable tok repr =>-  repr a -> String+showGrammar :: forall showName a tok.+  HideableName showName =>+  Grammarable tok (Grammar (ViewGrammar showName)) =>+  Grammar (ViewGrammar showName) a -> String showGrammar = show . viewGrammar . grammar @tok
src/Symantic/Parser/Grammar/Combinators.hs view
@@ -8,6 +8,7 @@ {-# LANGUAGE DeriveGeneric #-} -- For NFData instances {-# LANGUAGE DeriveAnyClass #-} -- For NFData instances {-# LANGUAGE DeriveLift #-} -- For TH.Lift (Exception tok)+{-# LANGUAGE DerivingStrategies #-} -- For UnscopedRegister {-# LANGUAGE PatternSynonyms #-} -- For Failure {-# LANGUAGE StandaloneDeriving #-} -- For Show (Exception (InputToken inp)) {-# LANGUAGE InstanceSigs #-}@@ -28,7 +29,7 @@ import Data.Either (Either(..)) import Data.Eq (Eq(..)) import Data.Ord (Ord(..), Ordering(..))-import Data.Function ((.), flip, const)+import Data.Function ((.), flip, const, fix) import Data.Int (Int) import Data.Kind (Type, Constraint) import Data.Maybe (Maybe(..))@@ -42,8 +43,8 @@ import qualified Language.Haskell.TH as TH import qualified Language.Haskell.TH.Syntax as TH -import Symantic.Typed.Derive-import qualified Symantic.Typed.Lang as Prod+import Symantic.Derive+import qualified Symantic.Lang as Prod import Symantic.Parser.Grammar.Production  -- * Type 'ReprComb'@@ -112,8 +113,7 @@   , TH.Lift (Failure comb)   , NFData (Failure comb)   , Typeable comb-  ) =>-  SomeFailure (Failure comb {-repr a-})+  ) => SomeFailure (Failure comb {-repr a-}) instance Eq SomeFailure where   SomeFailure (x::Failure x) == SomeFailure (y::Failure y) =     case typeRep @x `eqTypeRep` typeRep @y of@@ -286,18 +286,17 @@  -- * Class 'CombFoldable' class CombFoldable repr where-  chainPre :: repr (a -> a) -> repr a -> repr a+  chainPre  :: repr (a -> a) -> repr a -> repr a   chainPost :: repr a -> repr (a -> a) -> repr a-  {-+  chainPre  = liftDerived2 chainPre+  chainPost = liftDerived2 chainPost   default chainPre ::     FromDerived2 CombFoldable repr =>     repr (a -> a) -> repr a -> repr a   default chainPost ::     FromDerived2 CombFoldable repr =>     repr a -> repr (a -> a) -> repr a-  chainPre = liftDerived2 chainPre-  chainPost = liftDerived2 chainPost-  -}+  {-   default chainPre ::     CombApplicable repr =>     CombAlternable repr =>@@ -308,6 +307,7 @@     repr a -> repr (a -> a) -> repr a   chainPre op p = go <*> p where go = (Prod..) <$> op <*> go <|> pure Prod.id   chainPost p op = p <**> go where go = (Prod..) <$> op <*> go <|> pure Prod.id+  -}   {-   chainPre op p = flip (foldr ($)) <$> many op <*> p   chainPost p op = foldl' (flip ($)) <$> p <*> many op@@ -448,17 +448,36 @@ -- * Class 'CombMatchable' class CombMatchable repr where   conditional ::-    Eq a => repr a -> [Production (a -> Bool)] -> [repr b] -> repr b -> repr b+    repr a -> [(Production (a -> Bool), repr b)] -> repr b -> repr b+  conditional a bs = liftDerived1+    (conditional (derive a) ((\(p,b) -> (p, derive b)) Functor.<$> bs))   default conditional ::     FromDerived1 CombMatchable repr => Derivable repr =>-    Eq a => repr a -> [Production (a -> Bool)] -> [repr b] -> repr b -> repr b-  conditional a ps bs = liftDerived1 (conditional (derive a) ps (derive Functor.<$> bs))--  match :: Eq a => repr a -> [Production a] -> (Production a -> repr b) -> repr b -> repr b-  match a as a2b = conditional a ((Prod.equal Prod..@) Functor.<$> as) (a2b Functor.<$> as)-  -- match a as a2b = conditional a (((Prod.eq Prod..@ Prod.qual) Prod..@) Functor.<$> as) (a2b Functor.<$> as)+    repr a -> [(Production (a -> Bool), repr b)] -> repr b -> repr b data instance Failure CombMatchable +match ::+  CombMatchable repr =>+  Eq a => TH.Lift a =>+  repr a -> [Production a] -> (Production a -> repr b) -> repr b -> repr b+match a as p = conditional a+  ((\v ->+    ( Prod.lam (\x -> (Prod.==) Prod..@ v Prod..@ x)+    , p v+    )+  ) Functor.<$> as)++predicate ::+  CombMatchable repr =>+  Production (a -> Bool) -> repr a -> repr b -> repr b -> repr b+predicate p a b d = conditional a [(p, b)] d++infixl 4 <?:>+(<?:>) ::+  CombMatchable repr =>+  repr Bool -> (repr a, repr a) -> repr a+cond <?:> (p, q) = predicate Prod.id cond p q+ -- * Class 'CombSatisfiable' class CombSatisfiable tok repr where   -- | Like 'satisfyOrFail' but with no custom failure.@@ -589,6 +608,20 @@   branch = liftDerived3 branch data instance Failure CombSelectable +when ::+  CombMatchable repr =>+  CombSelectable repr =>+  Prod.Constantable () repr =>+  repr Bool -> repr () -> repr ()+when p q = p <?:> (q, Prod.unit)++while ::+  CombMatchable repr =>+  CombSelectable repr =>+  Prod.Constantable () repr =>+  repr Bool -> repr ()+while x = fix (when x)+ -- * Class 'CombLookable' class CombLookable repr where   look :: repr a -> repr a@@ -664,3 +697,97 @@ instance CombLookable repr => CombLookable (Sym.Any repr) instance CombFoldable repr => CombFoldable (Sym.Any repr) -}++-- * Type 'Register'+newtype Register r a = Register { unRegister :: UnscopedRegister a }+  deriving (Eq, Show)++-- ** Type 'UnscopedRegister'+newtype UnscopedRegister r = UnscopedRegister { unUnscopedRegister :: TH.Name }+  deriving (Eq)+  deriving newtype Show+++{-+put_ :: ParserOps rep => Register r a -> rep a -> Parser ()+put_ r = put r . pure++gets_ :: ParserOps rep => Register r a -> rep (a -> b) -> Parser b+gets_ r = gets r . pure++modify_ :: ParserOps rep => Register r a -> rep (a -> a) -> Parser ()+modify_ r = modify r . pure+-}++gets ::+  CombApplicable repr =>+  CombRegisterable repr =>+  Register r a -> repr (a -> b) -> repr b+gets r p = p <*> get r++modify ::+  CombApplicable repr =>+  CombRegisterable repr =>+  Register r a -> repr (a -> a) -> repr ()+modify r p = put r (gets r p)++move ::+  CombRegisterable repr =>+  Register r1 a -> Register r2 a -> repr ()+move dst src = put dst (get src)++bind ::+  CombRegisterable repr =>+  repr a -> (repr a -> repr b) -> repr b+bind p f = new p (f . get)++local ::+  CombApplicable repr =>+  CombRegisterable repr =>+  Register r a -> repr a -> repr b -> repr b+local r p q = bind (get r) (\x -> put r p *> q <* put r x)++swap ::+  CombApplicable repr =>+  CombRegisterable repr =>+  Register r1 a -> Register r2 a -> repr ()+swap r1 r2 = bind (get r1) (\x -> move r1 r2 *> put r2 x)++rollback ::+  CombAlternable repr =>+  CombApplicable repr =>+  CombRegisterable repr =>+  Register r a -> repr b -> repr b+rollback r p = bind (get r) (\x -> p <|> put r x *> empty)++for ::+  CombApplicable repr =>+  CombMatchable repr =>+  CombSelectable repr =>+  CombRegisterable repr =>+  Prod.Constantable () repr =>+  repr a -> repr (a -> Bool) -> repr (a -> a) -> repr () -> repr ()+for init cond step body =+  new init (\i ->+    let cond' = gets i cond in+    when cond' (while (body *> modify i step *> cond'))+  )+++-- ** Class 'CombRegisterable'+class CombRegisterable (repr::ReprComb) where+  new :: repr a -> (forall r. Register r a -> repr b) -> repr b+  get :: Register r a -> repr a+  put :: Register r a -> repr a -> repr ()+  default new ::+    FromDerived CombRegisterable repr => Derivable repr =>+    repr a -> (forall r. Register r a -> repr b) -> repr b+  default get ::+    FromDerived CombRegisterable repr =>+    Register r a -> repr a+  default put ::+    FromDerived1 CombRegisterable repr =>+    Register r a -> repr a -> repr ()+  new ini f = liftDerived (new (derive ini) (derive . f))+  get = liftDerived . get+  put = liftDerived1 . put
src/Symantic/Parser/Grammar/ObserveSharing.hs view
@@ -1,19 +1,22 @@+{-# LANGUAGE DefaultSignatures #-}+{-# LANGUAGE TupleSections #-} {-# OPTIONS_GHC -fno-warn-orphans #-} module Symantic.Parser.Grammar.ObserveSharing-  ( module Symantic.Typed.ObserveSharing+  ( module Symantic.ObserveSharing   , module Symantic.Parser.Grammar.ObserveSharing   ) where  import Control.Monad (mapM) import Data.Function (($), (.)) import Data.Hashable (Hashable, hashWithSalt)+import System.IO.Unsafe (unsafePerformIO) -- For 'new' import Text.Show (Show(..))-import qualified Control.Applicative as Functor+import qualified Control.Applicative as F  import Symantic.Parser.Grammar.Combinators-import Symantic.Typed.Derive-import Symantic.Typed.ObserveSharing hiding (observeSharing)-import qualified Symantic.Typed.ObserveSharing as ObserveSharing+import Symantic.Derive+import Symantic.ObserveSharing hiding (observeSharing)+import qualified Symantic.ObserveSharing as ObserveSharing import qualified Language.Haskell.TH.Syntax as TH  -- | Like 'Observable.observeSharing'@@ -30,51 +33,110 @@   makeLetName _ = TH.qNewName "name"  -- Combinators semantics for the 'ObserveSharing' interpreter.-instance (Letable TH.Name repr, CombAlternable repr) =>-  CombAlternable (ObserveSharing TH.Name repr)-instance (Letable TH.Name repr, CombApplicable repr) =>-  CombApplicable (ObserveSharing TH.Name repr) instance-  ( Letable TH.Name repr-  , CombFoldable repr-  {- TODO: the following constraints are for the current CombFoldable,-   - they will have to be removed when CombFoldable will have 'liftDerived2' as defaults-   -}-  , CombApplicable repr+  ( Referenceable TH.Name repr   , CombAlternable repr+  ) => CombAlternable (ObserveSharing TH.Name repr)+instance+  ( Referenceable TH.Name repr+  , CombApplicable repr+  ) => CombApplicable (ObserveSharing TH.Name repr)+instance+  ( Referenceable TH.Name repr+  , CombFoldable repr   ) => CombFoldable (ObserveSharing TH.Name repr)-instance (Letable TH.Name repr, CombLookable repr) =>-  CombLookable (ObserveSharing TH.Name repr)-instance (Letable TH.Name repr, CombMatchable repr) =>-  CombMatchable (ObserveSharing TH.Name repr) where+instance+  ( Referenceable TH.Name repr+  , CombLookable repr+  ) => CombLookable (ObserveSharing TH.Name repr)+instance+  ( Referenceable TH.Name repr+  , CombMatchable repr+  ) => CombMatchable (ObserveSharing TH.Name repr) where   -- Here the default definition does not fit-  -- since there is no lift* for the type of 'conditional'+  -- since there is no liftDerived* for the type of 'conditional'   -- and its default definition does not handles 'bs'-  -- as needed by the 'ObserveSharing' transformation.-  conditional a cs bs b = observeSharingNode $ ObserveSharing $-    conditional-      Functor.<$> unObserveSharing a-      Functor.<*> Functor.pure cs-      Functor.<*> mapM unObserveSharing bs-      Functor.<*> unObserveSharing b-instance (Letable TH.Name repr, CombSelectable repr) =>-  CombSelectable (ObserveSharing TH.Name repr)-instance (Letable TH.Name repr, CombSatisfiable tok repr) =>-  CombSatisfiable tok (ObserveSharing TH.Name repr)+  -- as needed by the 'ObserveSharing' interpreter.+  conditional a bs d = observeSharingNode $ ObserveSharing $ conditional+    F.<$> unObserveSharing a+    F.<*> mapM (\(p, b) -> (p,) F.<$> unObserveSharing b) bs+    F.<*> unObserveSharing d+instance+  ( Referenceable TH.Name repr+  , CombSelectable repr+  ) => CombSelectable (ObserveSharing TH.Name repr)+instance+  ( Referenceable TH.Name repr+  , CombSatisfiable tok repr+  ) => CombSatisfiable tok (ObserveSharing TH.Name repr)+instance+  ( Referenceable TH.Name repr+  , CombRegisterableUnscoped repr+  ) => CombRegisterable (ObserveSharing TH.Name repr) where+  new ini f =+    -- 'unsafePerformIO' is used here because propagating 'IO'+    -- would prevent 'observeSharing' to recognize recursive let,+    -- causing an infinite loop on them.+    let !regName = unsafePerformIO $ TH.newName "reg" in+    let reg = UnscopedRegister regName in+    newUnscoped reg ini (f (Register reg))+  get = getUnscoped . unRegister+  put reg x = putUnscoped (unRegister reg) x+instance+  ( Referenceable TH.Name repr+  , CombRegisterableUnscoped repr+  ) => CombRegisterableUnscoped (ObserveSharing TH.Name repr) +-- * Class 'CombRegisterableUnscoped'+-- | These combinators are used to remove the @Rank2Types@ from 'CombRegisterable'+-- in order to be able to 'observeSharing'.+class CombRegisterableUnscoped (repr::ReprComb) where+  newUnscoped :: UnscopedRegister a -> repr a -> repr b -> repr b+  getUnscoped :: UnscopedRegister a -> repr a+  putUnscoped :: UnscopedRegister a -> repr a -> repr ()+  default newUnscoped ::+    FromDerived2 CombRegisterableUnscoped repr =>+    UnscopedRegister a -> repr a -> repr b -> repr b+  default getUnscoped ::+    FromDerived CombRegisterableUnscoped repr =>+    UnscopedRegister a -> repr a+  default putUnscoped ::+    FromDerived1 CombRegisterableUnscoped repr =>+    UnscopedRegister a -> repr a -> repr ()+  newUnscoped = liftDerived2 . newUnscoped+  getUnscoped = liftDerived . getUnscoped+  putUnscoped = liftDerived1 . putUnscoped+ -- Combinators semantics for the 'FinalizeSharing' interpreter.-instance CombApplicable repr => CombApplicable (FinalizeSharing TH.Name repr)-instance CombAlternable repr => CombAlternable (FinalizeSharing TH.Name repr)-instance CombFoldable repr => CombFoldable (FinalizeSharing TH.Name repr) where-  chainPre = liftDerived2 chainPre-  chainPost = liftDerived2 chainPost-instance CombLookable repr => CombLookable (FinalizeSharing TH.Name repr)-instance CombMatchable repr => CombMatchable (FinalizeSharing TH.Name repr) where-  conditional a cs bs b = FinalizeSharing $-    conditional-      Functor.<$> unFinalizeSharing a-      Functor.<*> Functor.pure cs-      Functor.<*> mapM unFinalizeSharing bs-      Functor.<*> unFinalizeSharing b-instance CombSatisfiable tok repr => CombSatisfiable tok (FinalizeSharing TH.Name repr)-instance CombSelectable repr => CombSelectable (FinalizeSharing TH.Name repr)+instance+  ( CombApplicable repr+  ) => CombApplicable (FinalizeSharing TH.Name repr)+instance+  ( CombAlternable repr+  ) => CombAlternable (FinalizeSharing TH.Name repr)+instance+  ( CombFoldable repr+  ) => CombFoldable (FinalizeSharing TH.Name repr)+instance+  ( CombLookable repr+  ) => CombLookable (FinalizeSharing TH.Name repr)+instance+  ( CombMatchable repr+  ) => CombMatchable (FinalizeSharing TH.Name repr) where+  conditional a bs d = FinalizeSharing $ conditional+    F.<$> unFinalizeSharing a+    F.<*> mapM (\(p, b) -> (p,) F.<$> unFinalizeSharing b) bs+    F.<*> unFinalizeSharing d+instance+  ( CombSatisfiable tok repr+  ) => CombSatisfiable tok (FinalizeSharing TH.Name repr)+instance+  ( CombSelectable repr+  ) => CombSelectable (FinalizeSharing TH.Name repr)+instance+  ( CombRegisterableUnscoped repr+  ) => CombRegisterableUnscoped (FinalizeSharing TH.Name repr)++-- | Call trace stack updated by 'call' and 'refJoin'.+-- Used to avoid infinite loops when tying the knot with 'polyfix'.+type CallTrace = [TH.Name]
src/Symantic/Parser/Grammar/Optimize.hs view
@@ -1,12 +1,12 @@ {-# LANGUAGE PatternSynonyms #-} -- For Comb {-# LANGUAGE TemplateHaskell #-} -- For branch-{-# LANGUAGE ViewPatterns #-} -- For unSomeComb+{-# LANGUAGE ViewPatterns #-} -- For unSimplComb {-# OPTIONS_GHC -fno-warn-orphans #-} -- For MakeLetName TH.Name -- | Bottom-up optimization of 'Comb'inators, -- reexamining downward as needed after each optimization. module Symantic.Parser.Grammar.Optimize where -import Data.Bool (Bool(..))+import Data.Bool (Bool(..), (&&), not) import Data.Either (Either(..), either) import Data.Eq (Eq(..)) import Data.Function (($), (.))@@ -15,17 +15,22 @@ import Data.Set (Set) import Data.Functor.Identity (Identity(..)) import Data.Functor.Product (Product(..))+import Unsafe.Coerce (unsafeCoerce) import Type.Reflection (Typeable, typeRep, eqTypeRep, (:~~:)(..))+import Data.Semigroup (Semigroup(..)) import qualified Data.Foldable as Foldable-import qualified Data.Functor as Functor-import qualified Data.List as List+import qualified Data.Functor as F+import qualified Data.HashMap.Strict as HM+import qualified Data.HashSet as HS+import Data.Hashable (Hashable)+import qualified Language.Haskell.TH as TH  import Symantic.Parser.Grammar.Combinators import Symantic.Parser.Grammar.Production-import Symantic.Typed.Derive-import Symantic.Typed.ObserveSharing-import qualified Symantic.Typed.Data as Prod-import qualified Symantic.Typed.Lang as Prod+import Symantic.Parser.Grammar.ObserveSharing hiding (def)+import Symantic.Derive+import qualified Symantic.Data as Prod+import qualified Symantic.Lang as Prod  {- import Data.Function (($), flip)@@ -34,15 +39,87 @@ (&) = flip ($) infix 0 & -}+type OptimizeGrammar = KnotComb TH.Name --- * Type 'OptimizeGrammar'-type OptimizeGrammar = SomeComb+-- | TODO: remove useless wrapping?+newtype TiedComb repr a = TiedComb+  {  combSimpl :: SimplComb repr a+  --,  combRefs :: HS.HashSet letName+  } +-- * Type 'KnotComb'+data KnotComb letName repr a = KnotComb+  { knotCombOpens :: OpenRecs letName (SomeLet (TiedComb repr))+    -- ^ 'TiedComb' for all 'letName' in 'lets'.+  , knotCombOpen ::+      LetRecs letName (SomeLet (TiedComb repr)) ->+      TiedComb repr a+    -- ^ 'TiedComb' of the current combinator,+    -- with access to the final 'knotCombOpens'.+  }+ optimizeGrammar ::-  Derivable (SomeComb repr) =>-  SomeComb repr a -> repr a-optimizeGrammar = derive+  Derivable (SimplComb repr) =>+  KnotComb TH.Name repr a -> repr a+optimizeGrammar = derive . derive +type instance Derived (KnotComb letName repr) = SimplComb repr+instance Derivable (KnotComb letName repr) where+  derive opt = combSimpl $+    knotCombOpen opt (mutualFix (knotCombOpens opt))+instance LiftDerived (KnotComb letName repr) where+  liftDerived x = KnotComb+    { knotCombOpens = HM.empty+    , knotCombOpen = \_final -> TiedComb+        { combSimpl = x+        }+    }+instance LiftDerived1 (KnotComb letName repr) where+  liftDerived1 f a = a+    { knotCombOpen = \final -> TiedComb+      { combSimpl = f (combSimpl (knotCombOpen a final))+      }+    }+instance (Eq letName, Hashable letName) => LiftDerived2 (KnotComb letName repr) where+  liftDerived2 f a b = KnotComb+    { knotCombOpens = knotCombOpens a <> knotCombOpens b+    , knotCombOpen = \final -> TiedComb+      { combSimpl = f+         (combSimpl (knotCombOpen a final))+         (combSimpl (knotCombOpen b final))+      }+    }+instance (Eq letName, Hashable letName) => LiftDerived3 (KnotComb letName repr) where+  liftDerived3 f a b c = KnotComb+    { knotCombOpens = HM.unions+      [ knotCombOpens a+      , knotCombOpens b+      , knotCombOpens c+      ]+    , knotCombOpen = \final -> TiedComb+      { combSimpl = f+         (combSimpl (knotCombOpen a final))+         (combSimpl (knotCombOpen b final))+         (combSimpl (knotCombOpen c final))+      }+    }+instance (Eq letName, Hashable letName) => LiftDerived4 (KnotComb letName repr) where+  liftDerived4 f a b c d = KnotComb+    { knotCombOpens = HM.unions+      [ knotCombOpens a+      , knotCombOpens b+      , knotCombOpens c+      , knotCombOpens d+      ]+    , knotCombOpen = \final -> TiedComb+      { combSimpl = f+         (combSimpl (knotCombOpen a final))+         (combSimpl (knotCombOpen b final))+         (combSimpl (knotCombOpen c final))+         (combSimpl (knotCombOpen d final))+      }+    }+ -- * Data family 'Comb' -- | 'Comb'inators of the 'Grammar'. -- This is an extensible data-type.@@ -51,49 +128,65 @@   :: ReprComb -> ReprComb type instance Derived (Comb comb repr) = repr --- | Convenient utility to pattern-match a 'SomeComb'.-pattern Comb :: Typeable comb => Comb comb repr a -> SomeComb repr a-pattern Comb x <- (unSomeComb -> Just x)+-- | 'unsafeCoerce' restrained to 'SimplComb'.+-- Useful to avoid dependant-map when inlining.+unsafeSimplComb :: SimplComb repr a -> SimplComb repr b+unsafeSimplComb = unsafeCoerce --- ** Type 'SomeComb'--- | Some 'Comb'inator existentialized over the actual combinator symantic class.+-- | Convenient utility to pattern-match a 'SimplComb'.+pattern Comb :: Typeable comb => Comb comb repr a -> SimplComb repr a+pattern Comb x <- (unSimplComb -> Just x)++-- ** Type 'SimplComb'+-- | Interpreter simplifying combinators. -- Useful to handle a list of 'Comb'inators -- without requiring impredicative quantification. -- Must be used by pattern-matching--- on the 'SomeComb' data-constructor,+-- on the 'SimplComb' data-constructor, -- to bring the constraints in scope. -- -- The optimizations are directly applied within it, -- to avoid introducing an extra newtype, -- this also give a more understandable code.-data SomeComb repr a =+data SimplComb repr a =   forall comb.   (Derivable (Comb comb repr), Typeable comb) =>-  SomeComb (Comb comb repr a)+  SimplComb+    { combData :: Comb comb repr a+      -- ^ Some 'Comb'inator existentialized+      -- over the actual combinator symantic class.+    , combInline :: Bool+      -- ^ Whether this combinator must be inlined+      -- in place of a 'ref'erence pointing to it+      -- (instead of generating a 'call').+    , combRefs :: HS.HashSet TH.Name+      -- ^ 'ref''s names reacheable from combinator+      -- (including those behind 'ref's).+    } -type instance Derived (SomeComb repr) = repr-instance Derivable (SomeComb repr) where-  derive (SomeComb x) = derive x+type instance Derived (SimplComb repr) = repr+instance Derivable (SimplComb repr) where+  derive SimplComb{..} = derive combData --- | @(unSomeComb c :: 'Maybe' ('Comb' comb repr a))@--- extract the data-constructor from the given 'SomeComb'+-- | @(unSimplComb c :: 'Maybe' ('Comb' comb repr a))@+-- extract the data-constructor from the given 'SimplComb' -- iif. it belongs to the @('Comb' comb repr a)@ data-instance.-unSomeComb ::+unSimplComb ::   forall comb repr a.   Typeable comb =>-  SomeComb repr a -> Maybe (Comb comb repr a)-unSomeComb (SomeComb (c::Comb c repr a)) =+  SimplComb repr a -> Maybe (Comb comb repr a)+unSimplComb SimplComb{ combData = c :: Comb c repr a } =   case typeRep @comb `eqTypeRep` typeRep @c of     Just HRefl -> Just c     Nothing -> Nothing  -- CombAlternable data instance Comb CombAlternable repr a where-  Alt :: Exception -> SomeComb repr a -> SomeComb repr a -> Comb CombAlternable repr a+  Alt :: Exception -> SimplComb repr a -> SimplComb repr a -> Comb CombAlternable repr a   Empty :: Comb CombAlternable repr a   Failure :: SomeFailure -> Comb CombAlternable repr a   Throw :: ExceptionLabel -> Comb CombAlternable repr a-  Try :: SomeComb repr a -> Comb CombAlternable repr a+  Try :: SimplComb repr a -> Comb CombAlternable repr a instance CombAlternable repr => Derivable (Comb CombAlternable repr) where   derive = \case     Alt exn x y -> alt exn (derive x) (derive y)@@ -107,9 +200,17 @@   , CombLookable repr   , CombMatchable repr   , CombSelectable repr-  ) => CombAlternable (SomeComb repr) where-  empty = SomeComb Empty-  failure sf = SomeComb (Failure sf)+  ) => CombAlternable (SimplComb repr) where+  empty = SimplComb+    { combData = Empty+    , combInline = True+    , combRefs = HS.empty+    }+  failure sf = SimplComb+    { combData = Failure sf+    , combInline = True+    , combRefs = HS.empty+    }    alt _exn p@(Comb Pure{}) _ = p     -- & trace "Left Catch Law"@@ -123,30 +224,51 @@     -- & trace "Associativity Law"   alt exn (Comb (Look p)) (Comb (Look q)) = look (alt exn (try p) q)     -- & trace "Distributivity Law"-  alt exn x y = SomeComb (Alt exn x y)+  alt exn x y = SimplComb+    { combData = Alt exn x y+    , combInline = False+    , combRefs = combRefs x <> combRefs y+    } -  throw exn = SomeComb (Throw exn)+  throw exn = SimplComb+    { combData = Throw exn+    , combInline = True+    , combRefs = HS.empty+    }    try (Comb (p :$>: x)) = try p $> x     -- & trace "Try Interchange Law"   try (Comb (f :<$>: p)) = f <$> try p     -- & trace "Try Interchange Law"-  try x = SomeComb (Try x)+  try x = SimplComb+    { combData = Try x+    , combInline = False+    , combRefs = combRefs x+    }+instance+  ( CombApplicable repr+  , CombAlternable repr+  , CombLookable repr+  , CombMatchable repr+  , CombSelectable repr+  , Eq letName+  , Hashable letName+  ) => CombAlternable (KnotComb letName repr)  -- CombApplicable data instance Comb CombApplicable repr a where   Pure :: Production a -> Comb CombApplicable repr a-  (:<*>:) :: SomeComb repr (a -> b) -> SomeComb repr a -> Comb CombApplicable repr b-  (:<*:) :: SomeComb repr a -> SomeComb repr b -> Comb CombApplicable repr a-  (:*>:) :: SomeComb repr a -> SomeComb repr b -> Comb CombApplicable repr b+  (:<*>:) :: SimplComb repr (a -> b) -> SimplComb repr a -> Comb CombApplicable repr b+  (:<*:) :: SimplComb repr a -> SimplComb repr b -> Comb CombApplicable repr a+  (:*>:) :: SimplComb repr a -> SimplComb repr b -> Comb CombApplicable repr b infixl 4 :<*>:, :<*:, :*>:-pattern (:<$>:) :: Production (a -> b) -> SomeComb repr a -> Comb CombApplicable repr b+pattern (:<$>:) :: Production (a -> b) -> SimplComb repr a -> Comb CombApplicable repr b pattern t :<$>: x <- Comb (Pure t) :<*>: x-pattern (:$>:) :: SomeComb repr a -> Production b -> Comb CombApplicable repr b+pattern (:$>:) :: SimplComb repr a -> Production b -> Comb CombApplicable repr b pattern x :$>: t <- x :*>: Comb (Pure t) instance CombApplicable repr => Derivable (Comb CombApplicable repr) where   derive = \case-    Pure x -> pure (optimizeProduction x)+    Pure x -> pure x     f :<*>: x -> derive f <*> derive x     x :<*: y -> derive x <* derive y     x :*>: y -> derive x *> derive y@@ -156,20 +278,24 @@   , CombLookable repr   , CombMatchable repr   , CombSelectable repr-  ) => CombApplicable (SomeComb repr) where-  pure = SomeComb . Pure+  ) => CombApplicable (SimplComb repr) where+  pure a = SimplComb+    { combData = Pure a+    , combInline = False -- TODO: maybe True?+    , combRefs = HS.empty+    }   f <$> Comb (Branch b l r) =     branch b       ((Prod..) Prod..@ f <$> l)       ((Prod..) Prod..@ f <$> r)     -- & trace "Branch Distributivity Law"-  f <$> Comb (Conditional a ps bs d) =-    conditional a ps-      ((f <$>) Functor.<$> bs)-      (f <$> d)+  f <$> Comb (Conditional a bs def) =+    conditional a+      ((\(p, b) -> (p, f <$> b)) F.<$> bs)+      (f <$> def)     -- & trace "Conditional Distributivity Law"   -- Being careful here to use (<*>),-  -- instead of SomeComb (f <$> unOptComb x),+  -- instead of SimplComb { combData = f <$> combData x },   -- in order to apply the optimizations of (<*>).   f <$> x = pure f <*> x @@ -203,7 +329,11 @@   p <*> Comb (NegLook q) =     (p <*> pure Prod.unit) <* negLook q     -- & trace "Absorption Law"-  x <*> y = SomeComb (x :<*>: y)+  x <*> y = SimplComb+    { combData = x :<*>: y+    , combInline = False+    , combRefs = combRefs x <> combRefs y+    }    Comb Empty *> _ = empty     -- & trace "App Right Absorption Law"@@ -215,7 +345,11 @@     -- & trace "Identity Law"   u *> Comb (v :*>: w) = (u *> v) *> w     -- & trace "Associativity Law"-  x *> y = SomeComb (x :*>: y)+  x *> y = SimplComb+    { combData = x :*>: y+    , combInline = False+    , combRefs = combRefs x <> combRefs y+    }    Comb Empty <* _ = empty     -- & trace "App Right Absorption Law"@@ -229,54 +363,50 @@     -- & trace "Identity Law"   Comb (u :<*: v) <* w = u <* (v <* w)     -- & trace "Associativity Law"-  x <* y = SomeComb (x :<*: y)+  x <* y = SimplComb+    { combData = x :<*: y+    , combInline = False+    , combRefs = combRefs x <> combRefs y+    }+instance+  ( CombApplicable repr+  , CombAlternable repr+  , CombLookable repr+  , CombMatchable repr+  , CombSelectable repr+  , Eq letName+  , Hashable letName+  ) => CombApplicable (KnotComb letName repr)  -- CombFoldable data instance Comb CombFoldable repr a where-  ChainPreC :: SomeComb repr (a -> a) -> SomeComb repr a -> Comb CombFoldable repr a-  ChainPostC :: SomeComb repr a -> SomeComb repr (a -> a) -> Comb CombFoldable repr a+  ChainPre :: SimplComb repr (a -> a) -> SimplComb repr a -> Comb CombFoldable repr a+  ChainPost :: SimplComb repr a -> SimplComb repr (a -> a) -> Comb CombFoldable repr a instance CombFoldable repr => Derivable (Comb CombFoldable repr) where   derive = \case-    ChainPreC x y -> chainPre (derive x) (derive y)-    ChainPostC x y -> chainPost (derive x) (derive y)-instance CombFoldable repr => CombFoldable (SomeComb repr) where-  chainPre x = SomeComb . ChainPreC x-  chainPost x = SomeComb . ChainPostC x---- Letable-data instance Comb (Letable letName) repr a where-  Shareable :: letName -> SomeComb repr a -> Comb (Letable letName) repr a-  Ref :: Bool -> letName -> Comb (Letable letName) repr a-instance-  Letable letName repr =>-  Derivable (Comb (Letable letName) repr) where-  derive = \case-    Shareable n x -> shareable n (derive x)-    Ref isRec n -> ref isRec n-instance-  (Letable letName repr, Typeable letName) =>-  Letable letName (SomeComb repr) where-  shareable n = SomeComb . Shareable n-  ref isRec = SomeComb . Ref isRec---- Letsable-data instance Comb (Letsable letName) repr a where-  Lets :: LetBindings letName (SomeComb repr) ->-          SomeComb repr a -> Comb (Letsable letName) repr a-instance-  Letsable letName repr =>-  Derivable (Comb (Letsable letName) repr) where-  derive = \case-    Lets defs x -> lets ((\(SomeLet sub) -> SomeLet (derive sub)) Functor.<$> defs) (derive x)+    ChainPre op p -> chainPre (derive op) (derive p)+    ChainPost p op -> chainPost (derive p) (derive op)+instance CombFoldable repr => CombFoldable (SimplComb repr) where+  chainPre op p = SimplComb+    { combData = ChainPre op p+    , combInline = False+    , combRefs = combRefs op <> combRefs p+    }+  chainPost p op = SimplComb+    { combData = ChainPost p op+    , combInline = False+    , combRefs = combRefs p <> combRefs op+    } instance-  (Letsable letName repr, Typeable letName) =>-  Letsable letName (SomeComb repr) where-  lets defs = SomeComb . Lets defs+  ( CombFoldable repr+  , Eq letName+  , Hashable letName+  ) => CombFoldable (KnotComb letName repr)  -- CombLookable data instance Comb CombLookable repr a where-  Look :: SomeComb repr a -> Comb CombLookable repr a-  NegLook :: SomeComb repr a -> Comb CombLookable repr ()+  Look :: SimplComb repr a -> Comb CombLookable repr a+  NegLook :: SimplComb repr a -> Comb CombLookable repr ()   Eof :: Comb CombLookable repr () instance CombLookable repr => Derivable (Comb CombLookable repr) where   derive = \case@@ -289,7 +419,7 @@   , CombLookable repr   , CombSelectable repr   , CombMatchable repr-  ) => CombLookable (SomeComb repr) where+  ) => CombLookable (SimplComb repr) where   look p@(Comb Pure{}) = p     -- & trace "Pure Look Law"   look p@(Comb Empty) = p@@ -302,7 +432,11 @@     -- & trace "Interchange Law"   look (Comb (f :<$>: p)) = f <$> look p     -- & trace "Interchange Law"-  look x = SomeComb (Look x)+  look x = SimplComb+    { combData = Look x+    , combInline = False+    , combRefs = combRefs x+    }    negLook (Comb Pure{}) = empty     -- & trace "Pure Negative-Look"@@ -319,45 +453,86 @@     -- & trace "Transparency Law"   negLook (Comb (p :$>: _)) = negLook p     -- & trace "NegLook Idempotence Law"-  negLook x = SomeComb (NegLook x)+  negLook x = SimplComb+    { combData = NegLook x+    , combInline = False+    , combRefs = combRefs x+    } -  eof = SomeComb Eof+  eof = SimplComb+    { combData = Eof+    , combInline = True+    , combRefs = HS.empty+    }+instance+  ( CombLookable repr+  , CombAlternable repr+  , CombApplicable repr+  , CombSelectable repr+  , CombMatchable repr+  , Eq letName+  , Hashable letName+  ) => CombLookable (KnotComb letName repr)  -- CombMatchable data instance Comb CombMatchable repr a where-  Conditional :: Eq a =>-    SomeComb repr a ->-    [Production (a -> Bool)] ->-    [SomeComb repr b] ->-    SomeComb repr b ->+  Conditional ::+    SimplComb repr a ->+    [(Production (a -> Bool), SimplComb repr b)] ->+    SimplComb repr b ->     Comb CombMatchable repr b instance CombMatchable repr => Derivable (Comb CombMatchable repr) where   derive = \case-    Conditional a ps bs b ->+    Conditional a bs def ->       conditional (derive a)-        (optimizeProduction Functor.<$> ps)-        (derive Functor.<$> bs) (derive b)+        ((\(p, b) -> (p, derive b)) F.<$> bs)+        (derive def) instance   ( CombApplicable repr   , CombAlternable repr   , CombLookable repr   , CombSelectable repr   , CombMatchable repr-  ) => CombMatchable (SomeComb repr) where-  conditional (Comb Empty) _ _ d = d+  ) => CombMatchable (SimplComb repr) where+  conditional (Comb Empty) _ def = def     -- & trace "Conditional Absorption Law"-  conditional p _ qs (Comb Empty)-    | Foldable.all (\case { Comb Empty -> True; _ -> False }) qs = p *> empty-      -- & trace "Conditional Weakening Law"-  conditional a _ps bs (Comb Empty)-    | Foldable.all (\case { Comb Empty -> True; _ -> False }) bs = a *> empty+  conditional a bs (Comb Empty)+    | Foldable.all (\case { (_, Comb Empty) -> True; _ -> False }) bs = a *> empty       -- & trace "Conditional Weakening Law"-  conditional (Comb (Pure a)) ps bs d =-    Foldable.foldr (\(p, b) next ->-      if runValue (p Prod..@ a) then b else next-    ) d (List.zip ps bs)+  conditional (Comb (Pure a)) bs def =+    Foldable.foldr (\(p, b) acc ->+      if runValue (p Prod..@ a) then b else acc+    ) def bs     -- & trace "Conditional Pure Law"-  conditional a ps bs d = SomeComb (Conditional a ps bs d)+  conditional a bs d = SimplComb+    { combData = Conditional a bs d+    , combInline = False+    , combRefs = HS.unions+        $ combRefs a+        : combRefs d+        : ((\(_p, b) -> combRefs b) F.<$> bs)+    }+instance+  ( CombMatchable repr+  , CombAlternable repr+  , CombApplicable repr+  , CombLookable repr+  , CombSelectable repr+  , Eq letName+  , Hashable letName+  ) => CombMatchable (KnotComb letName repr) where+  conditional a bs d = KnotComb+    { knotCombOpens = HM.unions+        $ knotCombOpens a+        : knotCombOpens d+        : ((\(_p, b) -> knotCombOpens b) F.<$> bs)+    , knotCombOpen = \final -> TiedComb+        { combSimpl = conditional+            (combSimpl (knotCombOpen a final))+            ((\(p, b) -> (p, combSimpl (knotCombOpen b final))) F.<$> bs)+            (combSimpl (knotCombOpen d final))+        }+    }  -- CombSatisfiable data instance Comb (CombSatisfiable tok) repr a where@@ -377,18 +552,28 @@   CombSatisfiable tok repr =>   Derivable (Comb (CombSatisfiable tok) repr) where   derive = \case-    SatisfyOrFail fs p -> satisfyOrFail fs (optimizeProduction p)+    SatisfyOrFail fs p -> satisfyOrFail fs p instance   (CombSatisfiable tok repr, Typeable tok) =>-  CombSatisfiable tok (SomeComb repr) where-  satisfyOrFail fs = SomeComb . SatisfyOrFail fs+  CombSatisfiable tok (SimplComb repr) where+  satisfyOrFail fs p = SimplComb+    { combData = SatisfyOrFail fs p+    , combInline = False -- TODO: True? depending on p?+    , combRefs = HS.empty+    }+instance+  ( CombSatisfiable tok repr+  , Typeable tok+  , Eq letName+  , Hashable letName+  ) => CombSatisfiable tok (KnotComb letName repr)  -- CombSelectable data instance Comb CombSelectable repr a where   Branch ::-    SomeComb repr (Either a b) ->-    SomeComb repr (a -> c) ->-    SomeComb repr (b -> c) ->+    SimplComb repr (Either a b) ->+    SimplComb repr (a -> c) ->+    SimplComb repr (b -> c) ->     Comb CombSelectable repr c instance CombSelectable repr => Derivable (Comb CombSelectable repr) where   derive = \case@@ -399,7 +584,7 @@   , CombLookable repr   , CombSelectable repr   , CombMatchable repr-  ) => CombSelectable (SomeComb repr) where+  ) => CombSelectable (SimplComb repr) where   branch (Comb Empty) _ _ = empty     -- & trace "Branch Absorption Law"   branch b (Comb Empty) (Comb Empty) = b *> empty@@ -446,4 +631,135 @@                 Right r -> case $$(runCode lr) r of                              Left{} -> Left ()                              Right rr -> Right rr ||]-  branch b l r = SomeComb (Branch b l r)+  branch b l r = SimplComb+    { combData = Branch b l r+    , combInline = False+    , combRefs = HS.unions [ combRefs b, combRefs l, combRefs r ]+    }+instance+  ( CombSelectable repr+  , CombAlternable repr+  , CombApplicable repr+  , CombLookable repr+  , CombMatchable repr+  , Eq letName+  , Hashable letName+  ) => CombSelectable (KnotComb letName repr)++-- CombRegisterableUnscoped+data instance Comb CombRegisterableUnscoped repr a where+  NewUnscoped :: UnscopedRegister a -> SimplComb repr a -> SimplComb repr b -> Comb CombRegisterableUnscoped repr b+  GetUnscoped :: UnscopedRegister a -> Comb CombRegisterableUnscoped repr a+  PutUnscoped :: UnscopedRegister a -> SimplComb repr a -> Comb CombRegisterableUnscoped repr ()+instance CombRegisterableUnscoped repr => Derivable (Comb CombRegisterableUnscoped repr) where+  derive = \case+    NewUnscoped r ini x -> newUnscoped r (derive ini) (derive x)+    GetUnscoped r -> getUnscoped r+    PutUnscoped r x -> putUnscoped r (derive x)+instance -- TODO: optimizations+  ( CombRegisterableUnscoped repr+  ) => CombRegisterableUnscoped (SimplComb repr) where+  newUnscoped r ini x = SimplComb+    { combData = NewUnscoped r ini x+    , combInline = combInline ini && combInline x+    , combRefs = combRefs ini <> combRefs x+    }+  getUnscoped r = SimplComb+    { combData = GetUnscoped r+    , combInline = True+    , combRefs = HS.empty+    }+  putUnscoped r x = SimplComb+    { combData = PutUnscoped r x+    , combInline = combInline x+    , combRefs = combRefs x+    }+instance+  ( CombRegisterableUnscoped repr+  , Eq letName+  , Hashable letName+  ) => CombRegisterableUnscoped (KnotComb letName repr) where++-- Letsable+data instance Comb (Letsable letName) repr a where+  Lets ::+    LetBindings letName (SimplComb repr) ->+    SimplComb repr a ->+    Comb (Letsable letName) repr a+instance+  Letsable letName repr =>+  Derivable (Comb (Letsable letName) repr) where+  derive = \case+    Lets defs x -> lets+      ((\(SomeLet sub) -> SomeLet (derive sub)) F.<$> defs)+      (derive x)+instance+  (Letsable letName repr, Typeable letName) =>+  Letsable letName (SimplComb repr) where+  lets defs body = SimplComb+    { combData = Lets defs body+    , combInline = False+    , combRefs = HS.unions+        $ combRefs body+        : ((\(SomeLet sub) -> combRefs sub) F.<$> HM.elems defs)+    }+instance+  Letsable TH.Name repr =>+  Letsable TH.Name (KnotComb TH.Name repr) where+  lets defs body = KnotComb+    { knotCombOpens =+        HM.unions+          $ knotCombOpens body+          : ((\(SomeLet sub) -> SomeLet . knotCombOpen sub) F.<$> defs)+          -- Not really necessary to include 'knotCombOpens' of 'defs' here+          -- since there is only a single 'lets' at the top of the AST,+          -- but well.+          : ((\(SomeLet sub) -> knotCombOpens sub) F.<$> HM.elems defs)+    , knotCombOpen = \final -> TiedComb+        { combSimpl =+          let bodySimpl = combSimpl $ knotCombOpen body final in+          let defsSimpl = (\(SomeLet sub) -> SomeLet $ combSimpl $ knotCombOpen sub final) F.<$> defs in+          let defsUsed = HS.unions+                $ combRefs bodySimpl+                : ((\(SomeLet sub) -> combRefs sub) F.<$> HM.elems defsSimpl) in+          lets (HM.intersection defsSimpl (HS.toMap defsUsed)) bodySimpl+        }+    }++-- Referenceable+data instance Comb (Referenceable letName) repr a where+  Ref :: Bool -> letName -> Comb (Referenceable letName) repr a+instance+  Referenceable letName repr =>+  Derivable (Comb (Referenceable letName) repr) where+  derive = \case+    Ref isRec name -> ref isRec name+instance+  Referenceable TH.Name repr =>+  Referenceable TH.Name (SimplComb repr) where+  ref isRec name = SimplComb+    { combData = Ref isRec name+    , combInline = not isRec+    , combRefs = HS.singleton name+    }+instance+  Referenceable TH.Name repr =>+  Referenceable TH.Name (KnotComb TH.Name repr) where+  ref isRec name = KnotComb+    { knotCombOpens = HM.empty+    , knotCombOpen = \final ->+      if isRec+      then TiedComb+        { combSimpl = ref isRec name+        }+      else case final HM.! name of+        SomeLet a@TiedComb+          { combSimpl = p@SimplComb{ combInline = True }+          } -> a{combSimpl = unsafeSimplComb p}+        SomeLet TiedComb+          { combSimpl = SimplComb{ combRefs = refs }+          } -> TiedComb+            { combSimpl = (ref isRec name)+              { combRefs = HS.insert name refs }+            }+    }
src/Symantic/Parser/Grammar/Production.hs view
@@ -21,10 +21,9 @@ import qualified Language.Haskell.TH.Syntax as TH import qualified Language.Haskell.TH.Show as TH -import Symantic.Typed.Data-import Symantic.Typed.Lang-import Symantic.Typed.Optimize-import Symantic.Typed.Derive+import Symantic.Data+import Symantic.Lang+import Symantic.Derive  type Production = Product   (SomeData Identity)@@ -74,7 +73,7 @@  instance Show (SomeData TH.CodeQ a) where   -- The 'Derivable' constraint contained in 'SomeData'-  -- is 'TH.CodeQ', hence 'Symantic.Typed.View' cannot be used here.+  -- is 'TH.CodeQ', hence 'Symantic.View' cannot be used here.   -- Fortunately 'TH.showCode' can be implemented.   showsPrec p = showString Fun.. TH.showCode p Fun.. derive @@ -117,9 +116,6 @@   cons = Pair cons cons instance Equalable Production where   equal = Pair equal equal--optimizeProduction :: Production a -> Production a-optimizeProduction (Pair v c) = Pair (normalOrderReduction v) (normalOrderReduction c)  -- Identity instance Anythingable Identity
src/Symantic/Parser/Grammar/View.hs view
@@ -8,14 +8,17 @@ import Data.Semigroup (Semigroup(..)) import Data.String (String) import Data.Tuple (fst)+import Language.Haskell.TH.HideName import Text.Show (Show(..)) import qualified Data.Functor as Functor import qualified Data.HashMap.Strict as HM import qualified Data.List as List import qualified Data.Tree as Tree -import Symantic.Typed.ObserveSharing+import Symantic.ObserveSharing+import Symantic.Optimize (normalOrderReduction) import Symantic.Parser.Grammar.Combinators+import Symantic.Parser.Grammar.ObserveSharing import qualified Symantic.Parser.Grammar.Production as Prod  -- * Type 'ViewGrammar'@@ -25,6 +28,9 @@ viewGrammar :: ViewGrammar sN a -> ViewGrammar sN a viewGrammar = id +showProduction :: Prod.Production a -> String+showProduction p = showsPrec 10 (normalOrderReduction (Prod.prodCode p)) ""+ instance Show (ViewGrammar sN a) where   show = List.unlines . draw . unViewGrammar     where@@ -47,7 +53,7 @@   try x = ViewGrammar $ Tree.Node ("try", "") [unViewGrammar x] instance CombApplicable (ViewGrammar sN) where   _f <$> x = ViewGrammar $ Tree.Node ("<$>", "") [unViewGrammar x]-  pure a = ViewGrammar $ Tree.Node ("pure " <> showsPrec 10 (Prod.prodCode a) "", "") []+  pure a = ViewGrammar $ Tree.Node ("pure "<>showProduction a, "") []   x <*> y = ViewGrammar $ Tree.Node ("<*>", "") [unViewGrammar x, unViewGrammar y]   x <* y = ViewGrammar $ Tree.Node ("<*", "") [unViewGrammar x, unViewGrammar y]   x *> y = ViewGrammar $ Tree.Node ("*>", "") [unViewGrammar x, unViewGrammar y]@@ -55,38 +61,44 @@   chainPre f x = ViewGrammar $ Tree.Node ("chainPre", "") [unViewGrammar f, unViewGrammar x]   chainPost x f = ViewGrammar $ Tree.Node ("chainPost", "") [unViewGrammar x, unViewGrammar f] instance-  ShowLetName sN letName =>-  Letable letName (ViewGrammar sN) where-  shareable name x = ViewGrammar $-    Tree.Node ("shareable", " "<>showLetName @sN name) [unViewGrammar x]+  ( Show letName+  , HideName letName+  , HideableName sN+  ) => Referenceable letName (ViewGrammar sN) where   ref isRec name = ViewGrammar $     Tree.Node       ( if isRec then "rec" else "ref"-      , " "<>showLetName @sN name+      , " "<>show (hideableName @sN name)       ) [] instance-  ShowLetName sN letName =>-  Letsable letName (ViewGrammar sN) where+  ( Show letName+  , HideName letName+  , HideableName sN+  ) => Letsable letName (ViewGrammar sN) where   lets defs x = ViewGrammar $     Tree.Node ("lets", "") $       (<> [unViewGrammar x]) $       List.sortBy (compare `on` (((fst Functor.<$>) Functor.<$>) . Tree.levels)) $       HM.foldrWithKey'         (\name (SomeLet val) ->-          (Tree.Node ("let", " "<>showLetName @sN name) [unViewGrammar val] :))+          (Tree.Node ("let", " "<>show (hideableName @sN name)) [unViewGrammar val] :))         [] defs instance CombLookable (ViewGrammar sN) where   look x = ViewGrammar $ Tree.Node ("look", "") [unViewGrammar x]   negLook x = ViewGrammar $ Tree.Node ("negLook", "") [unViewGrammar x]   eof = ViewGrammar $ Tree.Node ("eof", "") [] instance CombMatchable (ViewGrammar sN) where-  conditional a _ps bs b = ViewGrammar $ Tree.Node ("conditional", "")-    [ unViewGrammar a-    , Tree.Node ("branches", "") (unViewGrammar Functor.<$> bs)-    , unViewGrammar b-    ]+  conditional a bs d = ViewGrammar $ Tree.Node ("conditional", "")+    $ Tree.Node ("condition", "") [unViewGrammar a]+    : Tree.Node ("default", "") [unViewGrammar d]+    : ((\(p,b) -> Tree.Node ("branch "<>showProduction p, "") [unViewGrammar b]) Functor.<$> bs) instance CombSatisfiable tok (ViewGrammar sN) where-  satisfyOrFail _fs _p = ViewGrammar $ Tree.Node ("satisfy", "") []+  satisfyOrFail _fs p = ViewGrammar $ Tree.Node+    ("satisfy "<>showProduction p, "") [] instance CombSelectable (ViewGrammar sN) where   branch lr l r = ViewGrammar $ Tree.Node ("branch", "")     [ unViewGrammar lr, unViewGrammar l, unViewGrammar r ]+instance CombRegisterableUnscoped (ViewGrammar sN) where+  newUnscoped r x y = ViewGrammar $ Tree.Node ("new "<>show r, "") [ unViewGrammar x,  unViewGrammar y ]+  getUnscoped r = ViewGrammar $ Tree.Node ("get "<>show r, "") [ ]+  putUnscoped r x = ViewGrammar $ Tree.Node ("put "<>show r, "") [ unViewGrammar x ]
src/Symantic/Parser/Grammar/Write.hs view
@@ -1,13 +1,14 @@ {-# LANGUAGE OverloadedStrings #-} module Symantic.Parser.Grammar.Write where -import Data.Bool (Bool(..)) import Control.Monad (Monad(..))+import Data.Bool (Bool(..)) import Data.Function (($)) import Data.Maybe (Maybe(..), fromMaybe, catMaybes) import Data.Monoid (Monoid(..)) import Data.Semigroup (Semigroup(..)) import Data.String (IsString(..))+import Language.Haskell.TH.HideName import Text.Show (Show(..)) import qualified Data.Functor as Functor import qualified Data.HashMap.Strict as HM@@ -15,8 +16,8 @@ import qualified Data.Text.Lazy as TL import qualified Data.Text.Lazy.Builder as TLB -import Symantic.Typed.ObserveSharing-import Symantic.Typed.Fixity+import Symantic.ObserveSharing+import Symantic.Fixity import Symantic.Parser.Grammar.Combinators  -- * Type 'WriteGrammar'@@ -83,7 +84,7 @@     where     op = infixN 9 instance CombApplicable (WriteGrammar sN) where-  pure _ = WriteGrammar $ return Nothing+  pure _ = WriteGrammar $ return Nothing{-TODO: print?-}   -- pure _ = "pure"   WriteGrammar x <*> WriteGrammar y = WriteGrammar $ \inh ->     let inh' side = inh@@ -114,30 +115,27 @@       unWriteGrammar x inh     where op = infixN 9 instance-  ShowLetName sN letName =>-  Letable letName (WriteGrammar sN) where-  shareable name x = WriteGrammar $ \inh ->-    pairWriteGrammarInh inh op $-      Just "shareable "-      <> Just (fromString (showLetName @sN name))-      <> unWriteGrammar x inh-    where-    op = infixN 9-  ref rec name = WriteGrammar $ \inh ->+  ( Show letName+  , HideName letName+  , HideableName sN+  ) => Referenceable letName (WriteGrammar sN) where+  ref isRec name = WriteGrammar $ \inh ->     pairWriteGrammarInh inh op $-      Just (if rec then "rec " else "ref ") <>-      Just (fromString (showLetName @sN name))+      Just (if isRec then "rec " else "ref ") <>+      Just (fromString (show (hideableName @sN name)))     where     op = infixN 9 instance-  ShowLetName sN letName =>-  Letsable letName (WriteGrammar sN) where+  ( Show letName+  , HideName letName+  , HideableName sN+  ) => Letsable letName (WriteGrammar sN) where   lets defs x = WriteGrammar $ \inh ->     pairWriteGrammarInh inh op $       Just "let "       <> HM.foldMapWithKey         (\name (SomeLet val) ->-          Just (fromString (showLetName @sN name))+          Just (fromString (show (hideableName @sN name)))           <> unWriteGrammar val inh)         defs       <> unWriteGrammar x inh@@ -154,16 +152,16 @@     where op = infixN 9   eof = "eof" instance CombMatchable (WriteGrammar sN) where-  conditional a _ps bs d = WriteGrammar $ \inh ->+  conditional a bs d = WriteGrammar $ \inh ->     pairWriteGrammarInh inh op $       Just "conditional " <>       unWriteGrammar a inh <>+      unWriteGrammar d inh <>       Just " [" <>       Just (mconcat (List.intersperse ", " $-      catMaybes $ (Functor.<$> bs) $ \x ->-        unWriteGrammar x inh{writeGrammarInh_op=(infixN 0, SideL)})) <>-      Just "] " <>-      unWriteGrammar d inh+      catMaybes $ (Functor.<$> bs) $ \(p{-TODO: print?-}, b) ->+        unWriteGrammar b inh{writeGrammarInh_op=(infixN 0, SideL)})) <>+      Just "] "     where     op = infixN 9 instance CombSatisfiable tok (WriteGrammar sN) where
src/Symantic/Parser/Machine.hs view
@@ -7,9 +7,9 @@   , module Symantic.Parser.Machine.Program   , module Symantic.Parser.Machine.View   ) where-import Data.Function ((.))+ import System.IO (IO)-import qualified Language.Haskell.TH.Syntax as TH+import Data.Function ((.))  import Symantic.Parser.Grammar import Symantic.Parser.Machine.Generate@@ -20,9 +20,7 @@ import Symantic.Parser.Machine.View  -- * Type 'Machine'-type Machine repr inp =-  ObserveSharing TH.Name-                 (OptimizeGrammar (Program repr inp))+type Machine repr inp = Grammar (Program repr inp)  -- | Build a 'Machine' able to 'generateCode' for the given 'Parser'. machine :: forall inp repr a.
src/Symantic/Parser/Machine/Generate.hs view
@@ -5,6 +5,7 @@ {-# LANGUAGE ConstraintKinds #-} -- For Dict {-# LANGUAGE TemplateHaskell #-} {-# LANGUAGE TupleSections #-}+{-# LANGUAGE MagicHash #-} {-# LANGUAGE UnboxedTuples #-} -- For nextInput {-# LANGUAGE UndecidableInstances #-} -- For Show (ParsingError inp) {-# OPTIONS_GHC -fno-warn-orphans #-}@@ -12,12 +13,14 @@  import Control.DeepSeq (NFData(..)) import Control.Monad (Monad(..))-import Data.Bool (Bool)+import Control.Monad.ST (ST, runST)+import Data.Bool (Bool(..), otherwise) import Data.Char (Char)-import Data.Either (Either(..), either)-import Data.Foldable (foldMap', toList, null)-import Data.Function (($), (.), id, const, on)-import Data.Functor (Functor, (<$>), (<$))+import Data.Either (Either(..))+import Data.Eq (Eq(..))+import Data.Foldable (foldr, toList, null)+import Data.Function (($), (.), on)+import Data.Functor ((<$>)) import Data.Int (Int) import Data.List.NonEmpty (NonEmpty(..)) import Data.Map (Map)@@ -28,6 +31,7 @@ import Data.Set (Set) import Data.String (String) import Data.Traversable (Traversable(..))+import Data.Tuple (snd) import Data.Typeable (Typeable) import Data.Word (Word8) import GHC.Generics (Generic)@@ -42,17 +46,27 @@ import qualified Data.Map.Strict as Map import qualified Data.Set as Set import qualified Data.Set.Internal as Set_+import qualified Data.STRef as ST import qualified Language.Haskell.TH as TH import qualified Language.Haskell.TH.Syntax as TH -import Symantic.Typed.Derive-import Symantic.Typed.ObserveSharing-import Symantic.Parser.Grammar.Combinators (Exception(..), Failure(..), SomeFailure(..), inputTokenProxy)+import qualified Symantic.Data as Sym+import Symantic.Derive+import Symantic.ObserveSharing+import qualified Symantic.Parser.Grammar as Gram+import Symantic.Parser.Grammar.Combinators+  ( UnscopedRegister(..)+  , Exception(..)+  , Failure(..)+  , SomeFailure(..)+  , unSomeFailure+  , inputTokenProxy+  ) import Symantic.Parser.Machine.Input import Symantic.Parser.Machine.Instructions import qualified Language.Haskell.TH.HideName as TH-import qualified Symantic.Typed.Lang as Prod-import qualified Symantic.Typed.Optimize as Prod+import qualified Symantic.Lang as Prod+import qualified Symantic.Optimize as Prod  --import Debug.Trace @@ -63,62 +77,79 @@ -- * Type 'Gen' -- | Generate the 'CodeQ' parsing the input. data Gen inp vs a = Gen-  { genAnalysisByLet :: LetMapFix (CallTrace -> GenAnalysis)+  { genAnalysisByLet :: OpenRecs TH.Name GenAnalysis     -- ^ 'genAnalysis' for each 'defLet' and 'defJoin' of the 'Machine'.-  , genAnalysis :: LetMapTo (CallTrace -> GenAnalysis)+  , genAnalysis :: OpenRec TH.Name GenAnalysis     -- ^ Synthetized (bottom-up) static genAnalysis of the 'Machine'.-  , unGen ::-      GenCtx inp vs a ->-      CodeQ (Either (ParsingError inp) a)+  , unGen :: forall st.+      GenCtx st inp vs a ->+      CodeQ (ST st (Either (ParsingError inp) a))   } +{-# INLINE returnST #-}+returnST :: forall s a. a -> ST s a+returnST = return @(ST s)+ -- | @('generateCode' input mach)@ generates @TemplateHaskell@ code -- parsing the given 'input' according to the given 'Machine'. generateCode ::-  {--  Eq (InputToken inp) =>-  NFData (InputToken inp) =>+  -- Not really used constraints,+  -- just to please 'checkHorizon'.+  Ord (InputToken inp) =>   Show (InputToken inp) =>-  Typeable (InputToken inp) =>   TH.Lift (InputToken inp) =>-  -}-  -- InputToken inp ~ Char =>+  NFData (InputToken inp) =>+  Typeable (InputToken inp) =>   Inputable inp =>   Show (Cursor inp) =>   Gen inp '[] a ->   CodeQ (inp -> Either (ParsingError inp) a)-generateCode k = [|| \(input :: inp) ->+generateCode gen =+    let Gen{unGen=k, ..} = checkHorizon gen in+    [|| \(input :: inp) ->     -- Pattern bindings containing unlifted types     -- should use an outermost bang pattern.     let !(# init, readMore, readNext #) = $$(cursorOf [||input||])-        finalRet = \_farInp _farExp v _inp -> Right v-        finalRaise :: forall b. (Catcher inp b)+        finalRet = \_farInp _farExp v _inp -> returnST $ Right v+        finalRaise :: forall st b. (OnException st inp b)           = \ !exn _failInp !farInp !farExp ->-          Left ParsingError+          returnST $ Left ParsingError           { parsingErrorOffset = offset farInp           , parsingErrorException = exn           , parsingErrorUnexpected =               if readMore farInp               then Just (let (# c, _ #) = readNext farInp in c)               else Nothing-          , parsingErrorExpecting = farExp+          , parsingErrorExpecting =+              let (minHoriz, res) =+                    Set.foldr (\f (minH, acc) ->+                      case unSomeFailure f of+                        Just (FailureHorizon h :: Failure (Gram.CombSatisfiable (InputToken inp)))+                          | Just old <- minH -> (Just (min old h), acc)+                          | otherwise -> (Just h, acc)+                        _ -> (minH, f:acc)+                      ) (Nothing, []) farExp in+              Set.fromList $ case minHoriz of+                Just h -> SomeFailure (FailureHorizon @(InputToken inp) h) : res+                Nothing -> res           }-    in-    $$(-      let defInputTokenProxy exprCode =-            TH.unsafeCodeCoerce $ do-              value <- TH.unTypeQ $ TH.examineCode [||Proxy :: Proxy (InputToken inp)||]-              expr <- TH.unTypeQ (TH.examineCode exprCode)-              return $ TH.LetE [-                TH.FunD inputTokenProxy [TH.Clause [] (TH.NormalB value) []]-                ] expr-      in defInputTokenProxy $-      unGen k GenCtx+    in runST $$(+      let+        -- | Defines 'inputTokenProxy' so that the TemplateHaskell code+        -- can refer to @(InputToken inp)@ through it.+        defInputTokenProxy :: TH.CodeQ a -> TH.CodeQ a+        defInputTokenProxy exprCode =+          TH.unsafeCodeCoerce [|+            let $(return (TH.VarP inputTokenProxy)) = Proxy :: Proxy (InputToken inp) in+            $(TH.unTypeQ (TH.examineCode exprCode))+          |]+      in+      defInputTokenProxy $+      k GenCtx         { valueStack = ValueStackEmpty-        , catchStackByLabel = Map.empty+        , onExceptionStackByLabel = Map.empty :: Map Exception (NonEmpty (TH.CodeQ (OnException s inp a)))         , defaultCatch = [||finalRaise||]-        , callStack = []-        , retCode = [||finalRet||]+        , onReturn = [||finalRet||] :: CodeQ (OnReturn s inp a a)         , input = [||init||]         , nextInput = [||readNext||]         , moreInput = [||readMore||]@@ -126,8 +157,7 @@         , farthestInput = [||init||]         , farthestExpecting = [||Set.empty||]         , checkedHorizon = 0-        , horizonStack = []-        , finalGenAnalysisByLet = runGenAnalysis (genAnalysisByLet k)+        , analysisByLet = mutualFix genAnalysisByLet         }       )     ||]@@ -177,68 +207,54 @@  -- * Type 'GenAnalysis' data GenAnalysis = GenAnalysis-  { minReads :: Either Exception Horizon+  { minReads :: Horizon+    -- ^ The minimun number of input tokens to read+    -- on the current 'input' to reach a success.   , mayRaise :: Map Exception ()+    -- ^ The 'Exception's that may be raised depending on the 'input'.+  , alwaysRaise :: Set Exception+    -- ^ The 'Exception's raised whatever is or happen to the 'input'.+  , freeRegs :: Set TH.Name+    -- ^ The free registers that are used.   } deriving (Show) --- | Tie the knot between mutually recursive 'TH.Name's--- introduced by 'defLet' and 'defJoin'.--- and provide the empty initial 'CallTrace' stack-runGenAnalysis ::-  LetMapFix (CallTrace -> GenAnalysis) ->-  LetMap GenAnalysis-runGenAnalysis ga = (($ []) <$>) $ polyfix ga---- | Poly-variadic fixpoint combinator.--- Used to express mutual recursion and to transparently introduce memoization,--- more precisely to "tie the knot"--- between observed sharing ('defLet', 'call', 'jump')--- and also between join points ('defJoin', 'refJoin').--- Because it's enough for its usage here,--- all mutually dependent functions are restricted to the same polymorphic type @(a)@.--- See http://okmij.org/ftp/Computation/fixed-point-combinators.html#Poly-variadic-polyfix :: Functor f => f (f a -> a) -> f a-polyfix fs = fix $ \finals -> ($ finals) <$> fs--fix :: (a -> a) -> a-fix f = final where final = f final--type LetMap = HM.HashMap TH.Name-type LetMapTo a = LetMap a -> a-type LetMapFix a = LetMap (LetMap a -> a)---- | Call trace stack updated by 'call' and 'refJoin'.--- Used to avoid infinite loops when tying the knot with 'polyfix'.-type CallTrace = [TH.Name]- -- ** Type 'Offset' type Offset = Int -- ** Type 'Horizon' -- | Minimal input length required for a successful parsing. type Horizon = Offset --- altGenAnalysis = List.foldl' (\acc x -> either Left (\h -> Right (either (const h) (min h) acc)) x) -- | Merge given 'GenAnalysis' as sequences. seqGenAnalysis :: NonEmpty GenAnalysis -> GenAnalysis seqGenAnalysis aas@(a:|as) = GenAnalysis-  { minReads = List.foldl' (\acc x ->-        acc >>= \r -> (r +) <$> minReads x-      ) (minReads a) as+  { minReads = List.foldl' (\acc -> (acc +) . minReads) (minReads a) as   , mayRaise = sconcat (mayRaise <$> aas)+  , alwaysRaise = sconcat (alwaysRaise <$> aas)+  , freeRegs = sconcat (freeRegs <$> aas)   } -- | Merge given 'GenAnalysis' as alternatives. altGenAnalysis :: NonEmpty GenAnalysis -> GenAnalysis-altGenAnalysis aas@(a:|as) = GenAnalysis-  { minReads = List.foldl' (\acc x ->-      either-        (\l -> either (const (Left  l)) Right)-        (\r -> either (const (Right r)) (Right . min r))-        acc (minReads x)-      ) (minReads a) as+altGenAnalysis aas = GenAnalysis+  { minReads =+      case+        (`NE.filter` aas) $ \a ->+          -- If an alternative 'alwaysRaise's 'ExceptionFailure' whatever its 'input' is,+          -- it __should__ remain semantically the same (up to the exact 'Failure's)+          -- to raise an 'ExceptionFailure' even before knowing+          -- whether that alternative branch will be taken or not,+          -- hence an upstream 'checkHorizon' is allowed to raise an 'ExceptionFailure'+          -- based only upon the 'minReads' of such alternatives:+          Set.toList (alwaysRaise a) /= [ExceptionFailure]+      of+      [] -> 0+      a:as -> List.foldl' (\acc -> min acc . minReads) (minReads a) as   , mayRaise = sconcat (mayRaise <$> aas)+  , alwaysRaise = foldr Set.intersection Set.empty (alwaysRaise <$> aas)+  , freeRegs = sconcat (freeRegs <$> aas)   }  + {- -- *** Type 'FarthestError' data FarthestError inp = FarthestError@@ -250,24 +266,22 @@ -- ** Type 'GenCtx' -- | This is an inherited (top-down) context -- only present at compile-time, to build TemplateHaskell splices.-data GenCtx inp vs a =+data GenCtx st inp vs a =   ( Cursorable (Cursor inp)-  {-+  -- For checkHorizon   , TH.Lift (InputToken inp)   , Show (InputToken inp)   , Eq (InputToken inp)+  , Ord (InputToken inp)   , Typeable (InputToken inp)   , NFData (InputToken inp)-  -}   ) => GenCtx   { valueStack :: ValueStack vs-  , catchStackByLabel :: Map Exception (NonEmpty (CodeQ (Catcher inp a)))-    -- | Default 'Catcher' defined at the begining of the generated 'CodeQ',+  , onExceptionStackByLabel :: Map Exception (NonEmpty (CodeQ (OnException st inp a)))+    -- | Default 'OnException' defined at the begining of the generated 'CodeQ',     -- hence a constant within the 'Gen'eration.-  , defaultCatch :: forall b. CodeQ (Catcher inp b)-    -- | Used by 'checkToken' to get 'GenAnalysis' from 'genAnalysis'.-  , callStack :: [TH.Name]-  , retCode :: CodeQ (Cont inp a a)+  , defaultCatch :: forall b. CodeQ (OnException st inp b)+  , onReturn :: CodeQ (OnReturn st inp a a)   , input :: CodeQ (Cursor inp)   , moreInput :: CodeQ (Cursor inp -> Bool)   , nextInput :: CodeQ (Cursor inp -> (# InputToken inp, Cursor inp #))@@ -280,11 +294,8 @@     -- Updated by 'checkHorizon'     -- and reset elsewhere when needed.   , checkedHorizon :: Horizon-  -- | Used by 'pushInput' and 'loadInput'-  -- to restore the 'Horizon' at the restored 'input'.-  , horizonStack :: [Horizon]-  -- | Output of 'runGenAnalysis'.-  , finalGenAnalysisByLet :: LetMap GenAnalysis+  -- | Output of 'mutualFix'.+  , analysisByLet :: LetRecs TH.Name GenAnalysis   }  -- ** Type 'ValueStack'@@ -295,21 +306,41 @@     , valueStackTail :: ValueStack vs     } -> ValueStack (v ': vs) +instance InstrComment Gen where+  comment msg k = k+    { unGen = \ctx -> {-trace "unGen.comment" $-}+      [||+        let _ = $$(liftTypedString $ "comment: "<>msg) in+        $$(unGen k ctx)+      ||]+    } instance InstrValuable Gen where   pushValue x k = k-    { unGen = \ctx -> {-trace "unGen.pushValue" $-} unGen k ctx-      { valueStack = ValueStackCons x (valueStack ctx) }+    { unGen = \ctx -> {-trace "unGen.pushValue" $-}+      [||+      let _ = "pushValue" in+      $$(unGen k ctx+        { valueStack = ValueStackCons x (valueStack ctx) })+      ||]     }   popValue k = k-    { unGen = \ctx -> {-trace "unGen.popValue" $-} unGen k ctx-      { valueStack = valueStackTail (valueStack ctx) }+    { unGen = \ctx -> {-trace "unGen.popValue" $-}+      [||+      let _ = "popValue" in+      $$(unGen k ctx+        { valueStack = valueStackTail (valueStack ctx) })+      ||]     }   lift2Value f k = k-    { unGen = \ctx -> {-trace "unGen.lift2Value" $-} unGen k ctx-      { valueStack =-        let ValueStackCons y (ValueStackCons x vs) = valueStack ctx in-        ValueStackCons (f Prod..@ x Prod..@ y) vs-      }+    { unGen = \ctx -> {-trace "unGen.lift2Value" $-}+      [||+      let _ = $$(liftTypedString ("lift2Value checkedHorizon="<>show (checkedHorizon ctx))) in+      $$(unGen k ctx+        { valueStack =+          let ValueStackCons y (ValueStackCons x vs) = valueStack ctx in+          ValueStackCons (f Prod..@ x Prod..@ y) vs+        })+      ||]     }   swapValue k = k     { unGen = \ctx -> {-trace "unGen.swapValue" $-} unGen k ctx@@ -321,7 +352,9 @@ instance InstrBranchable Gen where   caseBranch kx ky = Gen     { genAnalysisByLet = genAnalysisByLet kx <> genAnalysisByLet ky-    , genAnalysis = \final ct -> altGenAnalysis $ genAnalysis kx final ct :| [genAnalysis ky final ct]+    , genAnalysis = \final -> altGenAnalysis $+        genAnalysis kx final :|+        [genAnalysis ky final]     , unGen = \ctx -> {-trace "unGen.caseBranch" $-}       let ValueStackCons v vs = valueStack ctx in       [||@@ -330,30 +363,35 @@           Right y -> $$(unGen ky ctx{ valueStack = ValueStackCons (splice [||y||]) vs })       ||]     }-  choicesBranch fs ks kd = Gen-    { genAnalysisByLet = sconcat $ genAnalysisByLet kd :| (genAnalysisByLet <$> ks)-    , genAnalysis = \final ct -> altGenAnalysis $ (\k -> genAnalysis k final ct) <$> (kd:|ks)-    , unGen = \ctx -> {-trace "unGen.choicesBranch" $-}-      let ValueStackCons v vs = valueStack ctx in-      go ctx{valueStack = vs} v fs ks+  choicesBranch bs default_ = Gen+    { genAnalysisByLet = sconcat $ genAnalysisByLet default_ :| (genAnalysisByLet . snd <$> bs)+    , genAnalysis = \final -> altGenAnalysis $+        (\k -> genAnalysis k final)+        <$> (default_:|(snd <$> bs))+    , unGen = \ctx0 -> {-trace "unGen.choicesBranch" $-}+      let ValueStackCons v vs = valueStack ctx0 in+      let ctx = ctx0{valueStack = vs} in+      let+        go x ((p,b):bs') = [||+          if $$(genCode (p Prod..@ x))+          then+            let _ = $$(liftTypedString ("choicesBranch checkedHorizon="<>show (checkedHorizon ctx))) in+            $$({-trace "unGen.choicesBranch.b" $-} unGen b ctx)+          else+            let _ = "choicesBranch.else" in+            $$(go x bs')+          ||]+        go _ _ = unGen default_ ctx+      in go v bs     }-    where-    go ctx x (f:fs') (k:ks') = [||-      if $$(genCode (f Prod..@ x))-      then-        let _ = "choicesBranch.then" in-        $$({-trace "unGen.choicesBranch.k" $-} unGen k ctx)-      else-        let _ = "choicesBranch.else" in-        $$(go ctx x fs' ks')-      ||]-    go ctx _ _ _ = unGen kd ctx instance InstrExceptionable Gen where   raise exn = Gen     { genAnalysisByLet = HM.empty-    , genAnalysis = \_final _ct -> GenAnalysis-        { minReads = Left (ExceptionLabel exn)+    , genAnalysis = \_final -> GenAnalysis+        { minReads = 0         , mayRaise = Map.singleton (ExceptionLabel exn) ()+        , alwaysRaise = Set.singleton (ExceptionLabel exn)+        , freeRegs = Set.empty         }     , unGen = \ctx@GenCtx{} -> {-trace ("unGen.raise: "<>show exn) $-} [||         $$(raiseException ctx (ExceptionLabel exn))@@ -365,9 +403,11 @@     }   fail fs = Gen     { genAnalysisByLet = HM.empty-    , genAnalysis = \_final _ct -> GenAnalysis-        { minReads = Left ExceptionFailure+    , genAnalysis = \_final -> GenAnalysis+        { minReads = 0         , mayRaise = Map.singleton ExceptionFailure ()+        , alwaysRaise = Set.singleton ExceptionFailure+        , freeRegs = Set.empty         }     , unGen = \ctx@GenCtx{} -> {-trace ("unGen.fail: "<>show exn) $-}       if null fs@@ -382,81 +422,90 @@     }   commit exn k = k     { unGen = \ctx -> {-trace ("unGen.commit: "<>show exn) $-}-      unGen k ctx{catchStackByLabel =+      [||+      let _ = "commit" in+      $$(unGen k ctx{onExceptionStackByLabel =         Map.update (\case             _r0:|(r1:rs) -> Just (r1:|rs)             _ -> Nothing           )-        exn (catchStackByLabel ctx)-      }+        exn (onExceptionStackByLabel ctx)+      })+      ||]     }-  catch exn ok ko = Gen-    { genAnalysisByLet = genAnalysisByLet ok <> genAnalysisByLet ko-    , genAnalysis = \final ct ->-        let okGA = genAnalysis ok final ct in+  catch exn k onExn = Gen+    { genAnalysisByLet = genAnalysisByLet k <> genAnalysisByLet onExn+    , genAnalysis = \final ->+        let kAnalysis = genAnalysis k final in+        let onExnAnalysis = genAnalysis onExn final in         altGenAnalysis $-          okGA{ mayRaise = Map.delete exn (mayRaise okGA) } :|-          [ genAnalysis ko final ct ]+          kAnalysis+            { mayRaise = Map.delete exn (mayRaise kAnalysis)+            , alwaysRaise = Set.delete exn (alwaysRaise kAnalysis)+            } :|+          [ onExnAnalysis ]     , unGen = \ctx@GenCtx{} -> {-trace ("unGen.catch: "<>show exn) $-} [||-        let _ = $$(liftTypedString ("catch "<>show exn)) in-        let catchHandler !_exn !failInp !farInp !farExp =-              let _ = $$(liftTypedString ("catch.ko "<>show exn)) in-              $$({-trace ("unGen.catch.ko: "<>show exn) $-} unGen ko ctx-                -- Push 'input' and 'checkedHorizon'-                -- as they were when entering 'catch',-                -- they will be available to 'loadInput', if any.-                { valueStack =-                    ValueStackCons (splice (input ctx)) $-                    --ValueStackCons (Prod.var [||exn||]) $-                    valueStack ctx-                , horizonStack =-                    checkedHorizon ctx : horizonStack ctx-                -- Note that 'catchStackByLabel' is reset.-                -- Move the input to the failing position.-                , input = [||failInp||]-                -- The 'checkedHorizon' at the 'raise's are not known here.-                -- Nor whether 'failInp' is after 'checkedHorizon' or not.-                -- Hence fallback to a safe value.-                , checkedHorizon = 0-                -- Set the farthestInput to the farthest computed in 'fail'.-                , farthestInput = [||farInp||]-                , farthestExpecting = [||farExp||]-                })-        in-        $$({-trace ("unGen.catch.ok: "<>show es) $-} unGen ok ctx-        { catchStackByLabel =+        let _ = $$(liftTypedString ("catch "<>show exn<>" checkedHorizon="<>show (checkedHorizon ctx))) in+        let onException = $$(onExceptionCode (input ctx) (checkedHorizon ctx) onExn ctx) in+        $$(unGen k ctx+        { onExceptionStackByLabel =             Map.insertWith (<>) exn-              (NE.singleton [||catchHandler||])-              (catchStackByLabel ctx)+              (NE.singleton [||onException||])+              (onExceptionStackByLabel ctx)         }       ) ||]     }+-- ** Class 'SpliceInputable'+-- | Record an 'input' and a 'checkedHorizon' together+-- to be able to put both of them on the 'valueStack',+-- and having them moved together by operations+-- on the 'valueStack' (eg. 'lift2Value').+-- Used by 'saveInput' and 'loadInput'.+class SpliceInputable repr where+  inputSave :: CodeQ inp -> Horizon -> repr inp+data instance Sym.Data SpliceInputable repr a where+  InputSave :: CodeQ inp -> Horizon -> Sym.Data SpliceInputable repr inp+instance SpliceInputable (Sym.Data SpliceInputable repr) where+  inputSave = InputSave+instance SpliceInputable repr => SpliceInputable (Sym.SomeData repr) where+  inputSave inp = Sym.SomeData . InputSave inp+instance SpliceInputable TH.CodeQ where+  inputSave inp _hor = inp+instance SpliceInputable repr => Derivable (Sym.Data SpliceInputable repr) where+  derive = \case+    InputSave inp hor -> inputSave inp hor instance InstrInputable Gen where-  pushInput k = k+  saveInput k = k     { unGen = \ctx ->-        {-trace "unGen.pushInput" $-}-        unGen k ctx-          { valueStack = splice (input ctx) `ValueStackCons` valueStack ctx-          , horizonStack = checkedHorizon ctx : horizonStack ctx-          }+        {-trace "unGen.saveInput" $-}+        [||+        let _ = $$(liftTypedString $ "saveInput checkedHorizon="<>show (checkedHorizon ctx)) in+        $$(unGen k ctx+          { valueStack = inputSave (input ctx) (checkedHorizon ctx) `ValueStackCons` valueStack ctx+          })+        ||]     }   loadInput k = k-    { unGen = \ctx ->+    { unGen = \ctx@GenCtx{} ->         {-trace "unGen.loadInput" $-}-        let ValueStackCons input vs = valueStack ctx in-        let (h, hs) = case horizonStack ctx of-                        [] -> (0, [])-                        x:xs -> (x, xs) in-        unGen k ctx+        let ValueStackCons v vs = valueStack ctx in+        let (input, checkedHorizon) = case v of+              Sym.Data (InputSave i h) -> (i, h)+              -- This case should never happen if 'saveInput' is used.+              i -> (genCode i, 0) in+        [||+        let _ = $$(liftTypedString $ "loadInput checkedHorizon="<>show checkedHorizon) in+        $$(unGen (checkHorizon k) ctx           { valueStack = vs-          , horizonStack = hs-          , input = genCode input-          , checkedHorizon = h-          }-    , genAnalysis = \final ct -> GenAnalysis-        { minReads = 0 <$ minReads (genAnalysis k final ct)-        , mayRaise = mayRaise (genAnalysis k final ct)-        }+          , input+          , checkedHorizon+          })+        ||]+    , genAnalysis = \final ->+        let analysis = genAnalysis k final in+        -- The input is reset and thus any previous 'checkHorizon'+        -- cannot check after this 'loadInput'.+        analysis{minReads = 0}     } instance InstrCallable Gen where   defLet defs k = k@@ -468,113 +517,146 @@             {-trace "unGen.defLet.body" $-}             unGen k ctx           return $ TH.LetE (-            -- | Try to output more deterministic code to be able to golden test it,-            -- at the cost of more computations (at compile-time only though).+            -- | Use 'List.sortBy' to output more deterministic code+            -- to be able to golden test it, at the cost of more computations+            -- (at compile-time only though).             List.sortBy (compare `on` TH.hideName) $             toList decls             ) body     , genAnalysisByLet =-        foldMap' (\(SomeLet sub) -> genAnalysisByLet sub) defs <>-        ((\(SomeLet sub) -> genAnalysis sub) <$> defs) <>-        genAnalysisByLet k+        HM.unions+          $ genAnalysisByLet k+          : ((\(SomeLet sub) -> genAnalysis sub) <$> defs)+          : ((\(SomeLet sub) -> genAnalysisByLet sub) <$> HM.elems defs)     }     where-    makeDecl ctx (n, SomeLet sub) = do-      body <- TH.unTypeQ $ TH.examineCode $ [|| -- buildRec in Parsley+    makeDecl ctx (subName, SomeLet sub) = do+      let subAnalysis = analysisByLet ctx HM.! subName+      body <- takeFreeRegs (freeRegs subAnalysis) $+        TH.unTypeQ $ TH.examineCode $ [|| -- buildRec in Parsley         -- Called by 'call' or 'jump'.-        \ !ok{-from generateSuspend or retCode-}-          !inp-          !koByLabel{- 'catchStackByLabel' from the 'call'-site -} ->-          $$({-trace ("unGen.defLet.sub: "<>show n) $-} unGen sub ctx+        \ !callerOnReturn{-from onReturnCode-}+          !callerInput+          !callerOnExceptionStackByLabel{- 'onExceptionStackByLabel' from the 'call'-site -} ->+          $$({-trace ("unGen.defLet.sub: "<>show subName) $-} unGen sub ctx             { valueStack = ValueStackEmpty-            -- Build a 'catchStackByLabel' from the one available at the 'call'-site.-            -- Note that all the 'mayRaise' of the 'sub'routine may not be available,-            -- hence 'Map.findWithDefault' is used instead of 'Map.!'.-            , catchStackByLabel = Map.mapWithKey-                (\lbl () -> NE.singleton [||Map.findWithDefault $$(defaultCatch ctx) lbl koByLabel||])-                ({-trace ("mayRaise: "<>show n) $-}-                  mayRaise (finalGenAnalysisByLet ctx HM.! n))-            , input = [||inp||]-            , retCode = {-trace ("unGen.defLet.sub.retCode: "<>show n) $-} [||ok||]+            -- Build a 'onExceptionStackByLabel' for the 'mayRaise' of the subroutine,+            -- where each 'OnException' calls the one passed by the 'call'-site (in 'callerOnExceptionStackByLabel').+            -- Note that currently the 'call'-site can supply in 'callerOnExceptionStackByLabel'+            -- a subset of the 'mayRaise' needed by this subroutine,+            -- because 'Map.findWithDefault' is used instead of 'Map.!'.+            , onExceptionStackByLabel = Map.mapWithKey+                (\lbl () -> NE.singleton [||Map.findWithDefault $$(defaultCatch ctx) lbl callerOnExceptionStackByLabel||])+                ({-trace ("mayRaise: "<>show subName) $-}+                  mayRaise subAnalysis)+            , input = [||callerInput||]+            , onReturn = {-trace ("unGen.defLet.sub.onReturn: "<>show subName) $-} [||callerOnReturn||] -            -- These are passed by the caller via 'ok' or 'ko'+            -- These are passed by the caller via 'callerOnReturn' or 'ko'             -- , farthestInput =              -- , farthestExpecting =  -            -- Some callers can call this 'defLet'+            -- Some callers can call this declaration             -- with zero 'checkedHorizon', hence use this minimum.             -- TODO: maybe it could be improved a bit             -- by taking the minimum of the checked horizons-            -- before all the 'call's and 'jump's to this 'defLet'.+            -- before all the 'call's and 'jump's to this declaration.             , checkedHorizon = 0             })         ||]-      let decl = TH.FunD n [TH.Clause [] (TH.NormalB body) []]+      let decl = TH.FunD subName [TH.Clause [] (TH.NormalB body) []]       return decl-  jump (LetName n) = Gen+  jump isRec (LetName subName) = Gen     { genAnalysisByLet = HM.empty-    , genAnalysis = \final ct ->-        if n`List.elem`ct+    , genAnalysis = \final ->+        if isRec         then GenAnalysis-          { minReads = Right 0+          { minReads = 0           , mayRaise = Map.empty+          , alwaysRaise = Set.empty+          , freeRegs = Set.empty           }-        else (final HM.! n) (n:ct)-    , unGen = \ctx -> {-trace ("unGen.jump: "<>show n) $-} [||+        else final HM.! subName+    , unGen = \ctx -> {-trace ("unGen.jump: "<>show subName) $-}+      let subAnalysis = analysisByLet ctx HM.! subName in+      [||       let _ = "jump" in-      $$(TH.unsafeCodeCoerce (return (TH.VarE n)))-        {-ok-}$$(retCode ctx)+      $$(TH.unsafeCodeCoerce $+        giveFreeRegs (freeRegs subAnalysis) $+        return (TH.VarE subName))+        {-ok-}$$(onReturn ctx)         $$(input ctx)         $$(liftTypedRaiseByLabel $-          catchStackByLabel ctx+          onExceptionStackByLabel ctx           -- Pass only the labels raised by the 'defLet'.           `Map.intersection`-          (mayRaise $ finalGenAnalysisByLet ctx HM.! n)+          (mayRaise subAnalysis)         )       ||]     }-  call (LetName n) k = k-    { genAnalysis = \final ct ->-        if n`List.elem`ct+  call isRec (LetName subName) k = k+    { genAnalysis = \final ->+        if isRec         then GenAnalysis-          { minReads = Right 0+          { minReads = 0           , mayRaise = Map.empty+          , alwaysRaise = Set.empty+          , freeRegs = Set.empty           }-        else seqGenAnalysis $-          (final HM.! n) (n:ct) :|-          [ genAnalysis k final ct ]-    , unGen = {-trace ("unGen.call: "<>show n) $-} \ctx ->-      -- let ks = (Map.keys (catchStackByLabel ctx)) in+        else seqGenAnalysis $ (final HM.! subName) :| [ genAnalysis k final ]+    , unGen = {-trace ("unGen.call: "<>show subName) $-} \ctx ->+      -- let ks = (Map.keys (onExceptionStackByLabel ctx)) in+      let subAnalysis = analysisByLet ctx HM.! subName in       [||-      -- let _ = $$(liftTypedString $ "call exceptByLet("<>show n<>")="<>show (Map.keys (Map.findWithDefault Map.empty n (exceptByLet ctx))) <> " catchStackByLabel(ctx)="<> show ks) in-      $$(TH.unsafeCodeCoerce (return (TH.VarE n)))-        {-ok-}$$(generateSuspend k ctx{callStack = n : callStack ctx})+      -- let _ = $$(liftTypedString $ "call exceptByLet("<>show subName<>")="<>show (Map.keys (Map.findWithDefault Map.empty subName (exceptByLet ctx))) <> " onExceptionStackByLabel(ctx)="<> show ks) in+      $$(TH.unsafeCodeCoerce $+        giveFreeRegs (freeRegs subAnalysis) $+        return (TH.VarE subName))+        {-ok-}$$(onReturnCode k ctx)         $$(input ctx)         $$(liftTypedRaiseByLabel $-          catchStackByLabel ctx+          -- FIXME: maybe it should rather pass all the 'mayRaise' of 'subName'+          -- and 'defaultCatch' be removed from 'makeDecl''s 'onExceptionStackByLabel'.+          onExceptionStackByLabel ctx           -- Pass only the labels raised by the 'defLet'.           `Map.intersection`-          (mayRaise $ finalGenAnalysisByLet ctx HM.! n)+          (mayRaise subAnalysis)         )       ||]     }   ret = Gen     { genAnalysisByLet = HM.empty-    , genAnalysis = \_final _ct -> GenAnalysis-        { minReads = Right 0+    , genAnalysis = \_final -> GenAnalysis+        { minReads = 0         , mayRaise = Map.empty+        , alwaysRaise = Set.empty+        , freeRegs = Set.empty         }-    , unGen = \ctx -> {-trace "unGen.ret" $-} unGen ({-trace "unGen.ret.generateResume" $-} generateResume ({-trace "unGen.ret.retCode" $-} retCode ctx)) ctx+    , unGen = \ctx -> {-trace "unGen.ret" $-}+      {-trace "unGen.ret.returnCode" $-}+      returnCode ({-trace "unGen.ret.onReturn" $-} onReturn ctx) ctx     } +takeFreeRegs :: TH.Quote m => Set TH.Name -> m TH.Exp -> m TH.Exp+takeFreeRegs frs k = go (Set.toList frs)+  where+  go [] = k+  go (r:rs) = [| \ $(return (TH.VarP r)) -> $(go rs) |]++giveFreeRegs :: TH.Quote m => Set TH.Name -> m TH.Exp -> m TH.Exp+giveFreeRegs frs k = go (Set.toList frs)+  where+  go [] = k+  go (r:rs) = [| $(go rs) $(return (TH.VarE r)) |]+ -- | Like 'TH.liftString' but on 'TH.Code'. -- Useful to get a 'TH.StringL' instead of a 'TH.ListE'. liftTypedString :: String -> TH.Code TH.Q a liftTypedString = TH.unsafeCodeCoerce . TH.liftString --- | Like 'TH.liftTyped' but adjusted to work on 'catchStackByLabel'+-- | Like 'TH.liftTyped' but adjusted to work on 'onExceptionStackByLabel' -- which already contains 'CodeQ' terms.--- Moreover, only the 'Catcher' at the top of the stack+-- Moreover, only the 'OnException' at the top of the stack -- is needed and thus generated in the resulting 'CodeQ'. -- -- TODO: Use an 'Array' instead of a 'Map'?@@ -587,26 +669,27 @@   liftTyped Set_.Tip = [|| Set_.Tip ||]   liftTyped (Set_.Bin s a l r) = [|| Set_.Bin $$(TH.liftTyped s) $$(TH.liftTyped a) $$(TH.liftTyped l) $$(TH.liftTyped r) ||] --- ** Type 'Cont'-type Cont inp v a =+-- ** Type 'OnReturn'+-- | A continuation generated by 'onReturnCode' and later called by 'returnCode'.+type OnReturn st inp v a =   {-farthestInput-}Cursor inp ->-  {-farthestExpecting-}(Set SomeFailure) ->+  {-farthestExpecting-}Set SomeFailure ->   v ->   Cursor inp ->-  Either (ParsingError inp) a+  ST st (Either (ParsingError inp) a) --- | Generate a 'retCode' 'Cont'inuation to be called with 'generateResume'.+-- | Generate an 'OnReturn' continuation to be called with 'returnCode'. -- Used when 'call' 'ret'urns. -- The return 'v'alue is 'pushValue'-ed on the 'valueStack'.-generateSuspend ::+onReturnCode ::   {-k-}Gen inp (v ': vs) a ->-  GenCtx inp vs a ->-  CodeQ (Cont inp v a)-generateSuspend k ctx = [||-  let _ = $$(liftTypedString $ "suspend") in+  GenCtx st inp vs a ->+  CodeQ (OnReturn st inp v a)+onReturnCode k ctx = [||+  let _ = $$(liftTypedString $ "onReturn") in   \farInp farExp v !inp ->-    $$({-trace "unGen.generateSuspend" $-} unGen k ctx-      { valueStack = ValueStackCons ({-trace "unGen.generateSuspend.value" $-} splice [||v||]) (valueStack ctx)+    $$({-trace "unGen.onReturnCode" $-} unGen k ctx+      { valueStack = ValueStackCons ({-trace "unGen.onReturnCode.value" $-} splice [||v||]) (valueStack ctx)       , input = [||inp||]       , farthestInput = [||farInp||]       , farthestExpecting = [||farExp||]@@ -615,61 +698,85 @@     )   ||] --- | Generate a call to the 'generateSuspend' continuation.+-- | Generate a call to the 'onReturnCode' continuation. -- Used when 'call' 'ret'urns.-generateResume ::-  CodeQ (Cont inp v a) ->-  Gen inp (v ': vs) a-generateResume k = Gen-  { genAnalysisByLet = HM.empty-  , genAnalysis = \_final _ct -> GenAnalysis-      { minReads = Right 0-      , mayRaise = Map.empty-      }-  , unGen = \ctx -> {-trace "unGen.generateResume" $-} [||-    let _ = "resume" in-    $$k-      $$(farthestInput ctx)-      $$(farthestExpecting ctx)-      (let _ = "resume.genCode" in $$({-trace "unGen.generateResume.genCode" $-}-        genCode $ valueStackHead $ valueStack ctx))-      $$(input ctx)-    ||]-  }+returnCode ::+  CodeQ (OnReturn st inp v a) ->+  GenCtx st inp (v ': vs) a ->+  CodeQ (ST st (Either (ParsingError inp) a))+returnCode k = \ctx -> {-trace "returnCode" $-} [||+  let _ = "resume" in+  $$k+    $$(farthestInput ctx)+    $$(farthestExpecting ctx)+    (let _ = "resume.genCode" in $$({-trace "returnCode.genCode" $-}+      genCode $ valueStackHead $ valueStack ctx))+    $$(input ctx)+  ||] --- ** Type 'Catcher'-type Catcher inp a =+-- ** Type 'OnException'+-- | A continuation generated by 'catch' and later called by 'raise' or 'fail'.+type OnException st inp a =   Exception ->   {-failInp-}Cursor inp ->   {-farInp-}Cursor inp ->-  {-farExp-}(Set SomeFailure) ->-  Either (ParsingError inp) a+  {-farExp-}Set SomeFailure ->+  ST st (Either (ParsingError inp) a) +-- TODO: some static infos should be attached to 'OnException'+-- to avoid comparing inputs when they're the same+-- and to improve 'checkedHorizon'.+onExceptionCode ::+  CodeQ (Cursor inp) -> Horizon ->+  Gen inp (Cursor inp : vs) a ->+  GenCtx st inp vs a -> TH.CodeQ (OnException st inp a)+onExceptionCode resetInput resetCheckedHorizon k ctx = [||+  let _ = $$(liftTypedString $ "onException") in+  \ !_exn !failInp !farInp !farExp ->+    $$(unGen k ctx+      -- Push 'input' and 'checkedHorizon'+      -- as they were when entering the 'catch' or 'iter',+      -- they will be available to 'loadInput', if any.+      { valueStack = inputSave resetInput resetCheckedHorizon+                     `ValueStackCons` valueStack ctx+      -- Note that 'onExceptionStackByLabel' is reset.+      -- Move the input to the failing position.+      , input = [||failInp||]+      -- The 'checkedHorizon' at the 'raise's are not known here.+      -- Nor whether 'failInp' is after 'checkedHorizon' or not.+      -- Hence fallback to a safe value.+      , checkedHorizon = 0+      -- Set those to the farthest error computed in 'raiseFailure'.+      , farthestInput = [||farInp||]+      , farthestExpecting = [||farExp||]+      })+  ||]+ instance InstrJoinable Gen where   defJoin (LetName n) sub k = k-    { unGen =-        \ctx ->+    { unGen = \ctx ->         {-trace ("unGen.defJoin: "<>show n) $-}-        TH.unsafeCodeCoerce $ do-          next <- TH.unTypeQ $ TH.examineCode $ [||-            -- Called by 'generateResume'.-            \farInp farExp v !inp ->-              $$({-trace ("unGen.defJoin.next: "<>show n) $-} unGen sub ctx-                { valueStack = ValueStackCons (splice [||v||]) (valueStack ctx)-                , input = [||inp||]-                , farthestInput = [||farInp||]-                , farthestExpecting = [||farExp||]-                , checkedHorizon = 0-                {- FIXME:-                , catchStackByLabel = Map.mapWithKey-                    (\lbl () -> NE.singleton [||koByLabel Map.! lbl||])-                    (mayRaise sub raiseLabelsByLetButSub)-                -}-                })-            ||]-          let decl = TH.FunD n [TH.Clause [] (TH.NormalB next) []]-          expr <- TH.unTypeQ (TH.examineCode ({-trace ("unGen.defJoin.expr: "<>show n) $-} unGen k ctx))-          return (TH.LetE [decl] expr)+        TH.unsafeCodeCoerce [|+          let $(return (TH.VarP n)) = $(TH.unTypeQ $ TH.examineCode [||+                -- Called by 'returnCode'.+                \farInp farExp v !inp ->+                  $$({-trace ("unGen.defJoin.next: "<>show n) $-} unGen sub ctx+                    { valueStack = ValueStackCons (splice [||v||]) (valueStack ctx)+                    , input = [||inp||]+                    , farthestInput = [||farInp||]+                    , farthestExpecting = [||farExp||]+                    , checkedHorizon = 0+                    {- FIXME:+                    , onExceptionStackByLabel = Map.mapWithKey+                        (\lbl () -> NE.singleton [||koByLabel Map.! lbl||])+                        (mayRaise sub raiseLabelsByLetButSub)+                    -}+                    })+                ||])+          in $(TH.unTypeQ $ TH.examineCode $+            {-trace ("unGen.defJoin.expr: "<>show n) $-}+            unGen k ctx)+        |]     , genAnalysisByLet =         (genAnalysisByLet sub <>) $         HM.insert n (genAnalysis sub) $@@ -678,23 +785,96 @@   refJoin (LetName n) = Gen     { unGen = \ctx ->         {-trace ("unGen.refJoin: "<>show n) $-}-        unGen (generateResume-          (TH.unsafeCodeCoerce (return (TH.VarE n)))) ctx+        returnCode+          (TH.unsafeCodeCoerce (return (TH.VarE n))) ctx     , genAnalysisByLet = HM.empty-    , genAnalysis = \final ct ->-        if n`List.elem`ct -- FIXME: useless-        then GenAnalysis-          { minReads = Right 0-          , mayRaise = Map.empty-          }-        else HM.findWithDefault-          (error (show (n,ct,HM.keys final)))-          n final (n:ct)+    , genAnalysis = \final ->+        HM.findWithDefault+          (error (show (n,HM.keys final)))+          n final     } instance InstrReadable Char Gen where   read fs p = checkHorizon . checkToken fs p instance InstrReadable Word8 Gen where   read fs p = checkHorizon . checkToken fs p+instance InstrIterable Gen where+  iter (LetName loopJump) loop done = Gen+    { genAnalysisByLet = HM.unions+        [ -- No need to give 'freeRegs' when 'call'ing 'loopJump'+          -- because they're passed when 'call'ing 'iter'.+          -- This avoids to passing those registers around.+          HM.singleton loopJump (\final -> (genAnalysis loop final){freeRegs = Set.empty})+        , genAnalysisByLet loop+        , genAnalysisByLet done+        ]+    , genAnalysis = \final ->+      let loopAnalysis = genAnalysis loop final in+      let doneAnalysis = genAnalysis done final in+      GenAnalysis+        { minReads = minReads doneAnalysis+        , mayRaise =+            Map.delete ExceptionFailure (mayRaise loopAnalysis) <>+            mayRaise doneAnalysis+        , alwaysRaise =+            Set.delete ExceptionFailure (alwaysRaise loopAnalysis) <>+            alwaysRaise doneAnalysis+        , freeRegs = freeRegs loopAnalysis <> freeRegs doneAnalysis+        }+    , unGen = \ctx -> TH.unsafeCodeCoerce [|+        let _ = "iter" in+        let+          onException loopInput = $(TH.unTypeCode $ onExceptionCode+            (TH.unsafeCodeCoerce [|loopInput|]) 0 done ctx)+          $(return $ TH.VarP loopJump) = \_callerOnReturn callerInput callerOnExceptionStackByLabel ->+            $(TH.unTypeCode $ unGen loop ctx+              { valueStack = ValueStackEmpty+              , onExceptionStackByLabel =+                  Map.insertWith (<>) ExceptionFailure+                    (NE.singleton $ TH.unsafeCodeCoerce [|onException callerInput|])+                    (onExceptionStackByLabel ctx)+              , input = TH.unsafeCodeCoerce [|callerInput|]+              -- FIXME: promote to compile time error?+              , onReturn = TH.unsafeCodeCoerce [|error "invalid onReturn"|]+              , checkedHorizon = 0+              })+        in $(TH.unTypeCode $ unGen (jump True (LetName loopJump)) ctx{valueStack=ValueStackEmpty})+       |]+    }+instance InstrRegisterable Gen where+  newRegister (UnscopedRegister r) k = k+    { genAnalysis = \final ->+      let analysis = genAnalysis k final in+      analysis{freeRegs = Set.delete r $ freeRegs analysis}+    , unGen = \ctx ->+      let ValueStackCons v vs = valueStack ctx in+      TH.unsafeCodeCoerce [|+      do+        let dupv = $(TH.unTypeCode $ genCode v)+        $(return (TH.VarP r)) <- ST.newSTRef dupv+        $(TH.unTypeCode $ unGen k ctx{valueStack=vs})+      |]+    }+  readRegister (UnscopedRegister r) k = k+    { genAnalysis = \final ->+      let analysis = genAnalysis k final in+      analysis{freeRegs = Set.insert r $ freeRegs analysis}+    , unGen = \ctx -> [|| do+        sr <- ST.readSTRef $$(TH.unsafeCodeCoerce (return (TH.VarE r)))+        $$(unGen k ctx{valueStack=ValueStackCons (splice [||sr||]) (valueStack ctx)})+      ||]+    }+  writeRegister (UnscopedRegister r) k = k+    { genAnalysis = \final ->+      let analysis = genAnalysis k final in+      analysis{freeRegs = Set.insert r $ freeRegs analysis}+    , unGen = \ctx ->+      let ValueStackCons v vs = valueStack ctx in+      [|| do+        let dupv = $$(genCode v)+        ST.writeSTRef $$(TH.unsafeCodeCoerce (return (TH.VarE r))) dupv+        $$(unGen k ctx{valueStack=vs})+      ||]+    }  checkHorizon ::   forall inp vs a.@@ -708,38 +888,58 @@   {-ok-}Gen inp vs a ->   Gen inp vs a checkHorizon ok = ok-  { genAnalysis = \final ct -> seqGenAnalysis $-      GenAnalysis { minReads = Right 1+  { genAnalysis = \final -> seqGenAnalysis $+      GenAnalysis { minReads = 0                   , mayRaise = Map.singleton ExceptionFailure ()+                  , alwaysRaise = Set.empty+                  , freeRegs = Set.empty                   } :|-      [ genAnalysis ok final ct ]+      [ genAnalysis ok final ]   , unGen = \ctx0@GenCtx{} ->-    {-trace "unGen.checkHorizon" $-}-    let raiseFail = raiseException ctx0 ExceptionFailure in-    [||-      -- Factorize generated code for raising the "fail".-      let readFail = $$(raiseFail) in-      $$(-        let ctx = ctx0{catchStackByLabel =-                    Map.adjust (\(_r:|rs) -> [||readFail||] :| rs)-                      ExceptionFailure (catchStackByLabel ctx0)} in-        if checkedHorizon ctx >= 1-        then unGen ok ctx0{checkedHorizon = checkedHorizon ctx - 1}-        else let minHoriz =-                    either (\_err -> 0) id $-                    minReads $ finalGenAnalysis ctx ok in-          [||-          if $$(moreInput ctx)-               $$(if minHoriz > 0-                 then [||$$shiftRight minHoriz $$(input ctx)||]-                 else input ctx)-          then $$(unGen ok ctx{checkedHorizon = minHoriz})-          else let _ = "checkHorizon.else" in-            -- TODO: return a resuming continuation (eg. Partial)-            $$(unGen (fail (Set.singleton $ SomeFailure $ FailureHorizon @(InputToken inp) (minHoriz + 1))) ctx)-          ||]-      )-    ||]+    if checkedHorizon ctx0 >= 1+    then+      [||+        let _ = $$(liftTypedString $ "checkHorizon.oldCheck: checkedHorizon="<>show (checkedHorizon ctx0)) in+        $$(unGen ok ctx0{checkedHorizon = checkedHorizon ctx0 - 1})+      ||]+    else+      let minHoriz = minReads $ genAnalysis ok $ analysisByLet ctx0 in+      if minHoriz == 0+      then+        [||+          let _ = "checkHorizon.noCheck" in+          $$(unGen ok ctx0)+        ||]+      else+        [||+          let inp = $$(input ctx0) in+          --let partialCont inp =+                -- Factorize generated code for raising the "fail".+                let readFail = $$(raiseException ctx0{input=[||inp||]} ExceptionFailure) in+                $$(+                  let ctx = ctx0+                        { onExceptionStackByLabel =+                            Map.adjust (\(_r:|rs) -> [||readFail||] :| rs)+                              ExceptionFailure (onExceptionStackByLabel ctx0)+                        , input = [||inp||]+                        } in+                  [||+                    let _ = $$(liftTypedString $ "checkHorizon.newCheck: checkedHorizon="<>show (checkedHorizon ctx)<>" minHoriz="<>show minHoriz) in+                    if $$(moreInput ctx)+                         $$(if minHoriz > 1+                           then [||$$shiftRight $$(TH.liftTyped (minHoriz - 1)) inp||]+                           else [||inp||])+                    then $$(unGen ok ctx{checkedHorizon = minHoriz})+                    else+                      let _ = $$(liftTypedString $ "checkHorizon.newCheck.fail") in+                      -- TODO: return a resuming continuation (like attoparsec's Partial)+                      -- This could be done with a Buffer for efficient backtracking:+                      -- http://www.serpentine.com/blog/2014/05/31/attoparsec/+                      $$(unGen (fail (Set.singleton $ SomeFailure $ FailureHorizon @(InputToken inp) minHoriz)) ctx)+                  ||]+                )+          --in partialCont $$(input ctx0)+        ||]   }  -- | @('raiseFailure' ctx fs)@ raises 'ExceptionFailure'@@ -747,9 +947,9 @@ -- according to the relative position of 'input' wrt. 'farthestInput'. raiseFailure ::   Cursorable (Cursor inp) =>-  GenCtx inp cs a ->+  GenCtx st inp cs a ->   TH.CodeQ (Set SomeFailure) ->-  TH.CodeQ (Either (ParsingError inp) a)+  TH.CodeQ (ST st (Either (ParsingError inp) a)) raiseFailure ctx fs = [||   let failExp = $$fs in   let (# farInp, farExp #) =@@ -762,22 +962,14 @@     {-failInp-}$$(input ctx) farInp farExp   ||] -- | @('raiseException' ctx exn)@ raises exception @(exn)@--- using any entry in 'catchStackByLabel', or 'defaultCatch' if none.+-- using any entry in 'onExceptionStackByLabel', or 'defaultCatch' if none. raiseException ::-  GenCtx inp vs a -> Exception ->-  CodeQ (Exception -> Cursor inp -> Cursor inp -> Set SomeFailure -> Either (ParsingError inp) a)+  GenCtx st inp vs a -> Exception ->+  CodeQ (Exception -> Cursor inp -> Cursor inp -> Set SomeFailure -> ST st (Either (ParsingError inp) a)) raiseException ctx exn =   NE.head $ Map.findWithDefault     (NE.singleton (defaultCatch ctx))-    exn (catchStackByLabel ctx)--finalGenAnalysis :: GenCtx inp vs a -> Gen inp cs a -> GenAnalysis-finalGenAnalysis ctx k =-  --(\f -> f (error "callTrace")) $-  (\f -> f (callStack ctx)) $-  genAnalysis k $-  ((\f _ct -> f) <$>) $-  finalGenAnalysisByLet ctx+    exn (onExceptionStackByLabel ctx)  checkToken ::   Set SomeFailure ->@@ -785,7 +977,15 @@   {-ok-}Gen inp (InputToken inp ': vs) a ->   Gen inp vs a checkToken fs p ok = ok-  { unGen = \ctx -> {-trace "unGen.read" $-} [||+  { genAnalysis = \final -> seqGenAnalysis $+      GenAnalysis { minReads = 1+                  , mayRaise = Map.singleton ExceptionFailure ()+                  , alwaysRaise = Set.empty+                  , freeRegs = Set.empty+                  } :|+      [ genAnalysis ok final ]+  , unGen = \ctx -> {-trace "unGen.read" $-} [||+    let _ = "checkToken" in     let !(# c, cs #) = $$(nextInput ctx) $$(input ctx) in     $$(genCode $       Prod.ifThenElse@@ -795,7 +995,7 @@           , input = [||cs||]           })         (splice [||-          let _ = "checkToken.else" in+          let _ = "checkToken.fail" in           $$(unGen (fail fs) ctx)         ||])     )||]
src/Symantic/Parser/Machine/Input.hs view
@@ -2,6 +2,7 @@ {-# LANGUAGE MagicHash #-} {-# LANGUAGE TemplateHaskell #-} {-# LANGUAGE UnboxedTuples #-}+{-# LANGUAGE PolyKinds #-} module Symantic.Parser.Machine.Input where  import Data.Array.Base (UArray(..), listArray)@@ -21,7 +22,7 @@ import Data.Text.Internal (Text(..)) import Data.Text.Unsafe (iter, Iter(..), iter_, reverseIter_) import Text.Show (Show(..))-import GHC.Exts (Int(..), Char(..), {-, RuntimeRep(..)-})+import GHC.Exts (Int(..), Char(..) {-, RuntimeRep(..)-}, TYPE) import GHC.Word (Word8(..)) import GHC.ForeignPtr (ForeignPtr(..), ForeignPtrContents) import GHC.Prim ({-Int#,-} Addr#, nullAddr#, indexWideCharArray#, {-indexWord16Array#,-} readWord8OffAddr#, word2Int#, chr#, touch#, realWorld#, plusAddr#, (+#))@@ -146,7 +147,9 @@ class Cursorable (Cursor inp) => Inputable inp where   type Cursor inp :: Type   type InputToken inp :: Type-  cursorOf :: CodeQ inp -> CodeQ+  cursorOf :: CodeQ inp -> CodeQ (CursorOps inp)++type CursorOps (inp :: TYPE r) =     (# {-init-} Cursor inp     ,  {-more-} Cursor inp -> Bool     ,  {-next-} Cursor inp -> (# InputToken inp, Cursor inp #)
src/Symantic/Parser/Machine/Instructions.hs view
@@ -13,12 +13,13 @@ import Data.Kind (Type) import Data.Set (Set) import Text.Show (Show(..))+import Data.String (String) import qualified Language.Haskell.TH as TH  import Symantic.Parser.Grammar import Symantic.Parser.Machine.Input-import qualified Symantic.Typed.Lang as Prod-import qualified Symantic.Typed.Data as Sym+import qualified Symantic.Lang as Prod+import qualified Symantic.Data as Sym  -- * Type 'Splice' type Splice = Sym.SomeData TH.CodeQ@@ -38,6 +39,10 @@   deriving Eq   deriving newtype Show +-- ** Class 'InstrComment'+class InstrComment (repr::ReprInstr) where+  comment :: String -> repr inp vs a -> repr inp vs a+ -- ** Class 'InstrValuable' class InstrValuable (repr::ReprInstr) where   -- | @('pushValue' x k)@ pushes @(x)@ on the 'valueStack'@@ -85,17 +90,18 @@   -- to update the farthest error.   fail :: Set SomeFailure -> repr inp vs a   -- | @('commit' exn k)@ removes the 'Catcher'-  -- from the 'catchStackByLabel' for the given 'Exception' @(exn)@,+  -- from the 'onExceptionStackByLabel' for the given 'Exception' @(exn)@,   -- and continues with the next 'Instr'uction @(k)@.   commit :: Exception -> repr inp vs a -> repr inp vs a   -- | @('catch' exn l r)@ tries the @(l)@ 'Instr'uction   -- in a new failure scope such that if @(l)@ raises an exception within @(exn)@, it is caught,-  -- then the input (and its 'Horizon') is pushed as it was before trying @(l)@ on the 'valueStack',+  -- then the input (and its 'Horizon') is pushed+  -- as it was before trying @(l)@ on the 'valueStack' (resp. on the 'horizonStack'),   -- and the control flow goes on with the @(r)@ 'Instr'uction.   catch ::     Exception ->     {-scope-}repr inp vs ret ->-    {-catcher-}repr inp (Cursor inp ': vs) ret ->+    {-onException-}repr inp (Cursor inp ': vs) ret ->     repr inp vs ret  -- ** Class 'InstrBranchable'@@ -107,8 +113,7 @@     repr inp (Either x y ': vs) r   -- | @('choicesBranch' ps bs d)@.   choicesBranch ::-    [Splice (v -> Bool)] ->-    [repr inp vs a] ->+    [(Splice (v -> Bool), repr inp vs a)] ->     repr inp vs a ->     repr inp (v ': vs) a   -- | @('ifBranch' ok ko)@ pops a 'Bool' from the 'valueStack'@@ -118,7 +123,7 @@     repr inp vs a ->     repr inp vs a ->     repr inp (Bool ': vs) a-  ifBranch ok ko = choicesBranch [Prod.id] [ok] ko+  ifBranch ok ko = choicesBranch [(Prod.id, ok)] ko  -- ** Class 'InstrCallable' class InstrCallable (repr::ReprInstr) where@@ -129,16 +134,18 @@     LetBindings TH.Name (repr inp '[]) ->     repr inp vs a ->     repr inp vs a-  -- | @('call' n k)@ pass the control-flow to the 'DefLet' named @(n)@,+  -- | @('call' isRec n k)@ pass the control-flow to the 'DefLet' named @(n)@,   -- and when it 'Ret'urns, continues with the next 'Instr'uction @(k)@.   call ::+    Bool ->     LetName v -> repr inp (v ': vs) a ->     repr inp vs a   -- | @('ret')@ returns the value stored in a singleton 'valueStack'.   ret ::     repr inp '[a] a-  -- | @('jump' n k)@ pass the control-flow to the 'DefLet' named @(n)@.+  -- | @('jump' isRec n k)@ pass the control-flow to the 'DefLet' named @(n)@.   jump ::+    Bool ->     LetName a ->     repr inp '[] a @@ -154,12 +161,12 @@  -- ** Class 'InstrInputable' class InstrInputable (repr::ReprInstr) where-  -- | @('pushInput' k)@ pushes the input @(inp)@ on the 'valueStack'+  -- | @('saveInput' k)@ pushes the input @(inp)@ on the 'valueStackHead'   -- and continues with the next 'Instr'uction @(k)@.-  pushInput ::+  saveInput ::     repr inp (Cursor inp ': vs) a ->     repr inp vs a-  -- | @('loadInput' k)@ removes the input from the 'valueStack'+  -- | @('loadInput' k)@ removes the input from the 'valueStackHead'   -- and continues with the next 'Instr'uction @(k)@ using that input.   loadInput ::     repr inp vs a ->@@ -176,3 +183,37 @@     Splice (tok -> Bool) ->     repr inp (tok ': vs) a ->     repr inp vs a++-- ** Class 'InstrIterable'+class InstrIterable (repr::ReprInstr) where+  -- | @('iter' loop done)@.+  iter ::+    LetName a ->+    repr inp '[] a ->+    repr inp (Cursor inp ': vs) a ->+    repr inp vs a++-- ** Class 'InstrRegisterable'+class InstrRegisterable (repr::ReprInstr) where+  newRegister ::+    UnscopedRegister v ->+    repr inp vs a ->+    repr inp (v : vs) a+  readRegister ::+    UnscopedRegister v ->+    repr inp (v : vs) a ->+    repr inp vs a+  writeRegister ::+    UnscopedRegister v ->+    repr inp vs a ->+    repr inp (v : vs) a++-- | @('modifyRegister' reg k)@+-- modifies the content of register @(reg)@+-- with the function at the 'valueStackHead',+-- then continues with @(k)@.+modifyRegister ::+  InstrRegisterable repr =>+  InstrValuable repr =>+  UnscopedRegister v -> repr inp vs a -> repr inp ((v -> v) : vs) a+modifyRegister r = readRegister r . applyValue . writeRegister r
src/Symantic/Parser/Machine/Optimize.hs view
@@ -13,11 +13,12 @@ import Data.Kind (Constraint) import Data.Maybe (Maybe(..)) import Data.Set (Set)+import Data.String (String) import Type.Reflection (Typeable, typeRep, eqTypeRep, (:~~:)(..)) import qualified Data.Functor as Functor import qualified Language.Haskell.TH as TH -import Symantic.Typed.Derive+import Symantic.Derive import Symantic.Parser.Grammar import Symantic.Parser.Machine.Input import Symantic.Parser.Machine.Instructions@@ -47,13 +48,12 @@ -- As in 'SomeComb', a first pass of optimizations -- is directly applied in it -- to avoid introducing an extra newtype,--- this also give a more undestandable code.+-- this also gives a more undestandable code. data SomeInstr repr inp vs a =   forall instr.   ( Derivable (Instr instr repr inp vs)   , Typeable instr-  ) =>-  SomeInstr (Instr instr repr inp vs a)+  ) => SomeInstr (Instr instr repr inp vs a)  type instance Derived (SomeInstr repr inp vs) = repr inp vs instance Derivable (SomeInstr repr inp vs) where@@ -70,8 +70,23 @@ unSomeInstr (SomeInstr (i::Instr i repr inp vs a)) =   case typeRep @instr `eqTypeRep` typeRep @i of     Just HRefl -> Just i-    Nothing -> Nothing+    Nothing ->+      case typeRep @InstrComment `eqTypeRep` typeRep @i of+        Just HRefl | Comment _msg x <- i -> unSomeInstr x+        Nothing -> Nothing +-- InstrComment+data instance Instr InstrComment repr inp vs a where+  Comment ::+    String ->+    SomeInstr repr inp vs a ->+    Instr InstrComment repr inp vs a+instance InstrComment repr => Derivable (Instr InstrComment repr inp vs) where+  derive = \case+    Comment msg k -> comment msg (derive k)+instance InstrComment repr => InstrComment (SomeInstr repr) where+  comment msg = SomeInstr . Comment msg+ -- InstrValuable data instance Instr InstrValuable repr inp vs a where   PushValue ::@@ -90,9 +105,9 @@     Instr InstrValuable repr inp (y ': x ': vs) a instance InstrValuable repr => Derivable (Instr InstrValuable repr inp vs) where   derive = \case-    PushValue x k -> pushValue x (derive k)+    PushValue v k -> pushValue v (derive k)     PopValue k -> popValue (derive k)-    Lift2Value f k -> lift2Value f (derive k)+    Lift2Value v k -> lift2Value v (derive k)     SwapValue k -> swapValue (derive k) instance InstrValuable repr => InstrValuable (SomeInstr repr) where   -- 'PopValue' after a 'PushValue' is a no-op.@@ -138,17 +153,16 @@     SomeInstr repr inp (y ': vs) a ->     Instr InstrBranchable repr inp (Either x y ': vs) a   ChoicesBranch ::-    [Splice (v -> Bool)] ->-    [SomeInstr repr inp vs a] ->+    [(Splice (v -> Bool), SomeInstr repr inp vs a)] ->     SomeInstr repr inp vs a ->     Instr InstrBranchable repr inp (v ': vs) a instance InstrBranchable repr => Derivable (Instr InstrBranchable repr inp vs) where   derive = \case     CaseBranch l r -> caseBranch (derive l) (derive r)-    ChoicesBranch ps bs d -> choicesBranch ps (derive Functor.<$> bs) (derive d)+    ChoicesBranch bs d -> choicesBranch ((\(p,b) -> (p, derive b)) Functor.<$> bs) (derive d) instance InstrBranchable repr => InstrBranchable (SomeInstr repr) where   caseBranch l = SomeInstr . CaseBranch l-  choicesBranch ps bs = SomeInstr . ChoicesBranch ps bs+  choicesBranch bs = SomeInstr . ChoicesBranch bs  -- InstrCallable data instance Instr InstrCallable repr inp vs a where@@ -157,24 +171,26 @@     SomeInstr repr inp vs a ->     Instr InstrCallable repr inp vs a   Call ::+    Bool ->     LetName v ->     SomeInstr repr inp (v ': vs) a ->     Instr InstrCallable repr inp vs a   Ret ::     Instr InstrCallable repr inp '[a] a   Jump ::+    Bool ->     LetName a ->     Instr InstrCallable repr inp '[] a instance InstrCallable repr => Derivable (Instr InstrCallable repr inp vs) where   derive = \case     DefLet subs k -> defLet ((\(SomeLet sub) -> SomeLet (derive sub)) Functor.<$> subs) (derive k)-    Jump n -> jump n-    Call n k -> call n (derive k)+    Jump isRec n -> jump isRec n+    Call isRec n k -> call isRec n (derive k)     Ret -> ret instance InstrCallable repr => InstrCallable (SomeInstr repr) where   defLet subs = SomeInstr . DefLet subs-  jump = SomeInstr . Jump-  call n = SomeInstr . Call n+  jump isRec = SomeInstr . Jump isRec+  call isRec n = SomeInstr . Call isRec n   ret = SomeInstr Ret  -- InstrJoinable@@ -205,10 +221,10 @@     Instr InstrInputable repr inp (Cursor inp ': vs) a instance InstrInputable repr => Derivable (Instr InstrInputable repr inp vs) where   derive = \case-    PushInput k -> pushInput (derive k)+    PushInput k -> saveInput (derive k)     LoadInput k -> loadInput (derive k) instance InstrInputable repr => InstrInputable (SomeInstr repr) where-  pushInput = SomeInstr . PushInput+  saveInput = SomeInstr . PushInput   loadInput = SomeInstr . LoadInput  -- InstrReadable@@ -227,3 +243,48 @@   ( InstrReadable tok repr, Typeable tok ) =>   InstrReadable tok (SomeInstr repr) where   read fs p = SomeInstr . Read fs p++-- InstrIterable+data instance Instr InstrIterable repr inp vs a where+  Iter ::+    LetName a ->+    SomeInstr repr inp '[] a ->+    SomeInstr repr inp (Cursor inp ': vs) a ->+    Instr InstrIterable repr inp vs a+instance+  InstrIterable repr =>+  Derivable (Instr InstrIterable repr inp vs) where+  derive = \case+    Iter n op k -> iter n (derive op) (derive k)+instance+  InstrIterable repr =>+  InstrIterable (SomeInstr repr) where+  iter n op = SomeInstr . Iter n op++-- InstrRegisterable+data instance Instr InstrRegisterable repr inp vs a where+  NewRegister ::+    UnscopedRegister v ->+    SomeInstr repr inp vs a ->+    Instr InstrRegisterable repr inp (v : vs) a+  ReadRegister ::+    UnscopedRegister v ->+    SomeInstr repr inp (v : vs) a ->+    Instr InstrRegisterable repr inp vs a+  WriteRegister ::+    UnscopedRegister v ->+    SomeInstr repr inp vs a ->+    Instr InstrRegisterable repr inp (v : vs) a+instance+  InstrRegisterable repr =>+  Derivable (Instr InstrRegisterable repr inp vs) where+  derive = \case+    NewRegister r k -> newRegister r (derive k)+    ReadRegister r k -> readRegister r (derive k)+    WriteRegister r k -> writeRegister r (derive k)+instance+  InstrRegisterable repr =>+  InstrRegisterable (SomeInstr repr) where+  newRegister r = SomeInstr . NewRegister r+  readRegister r = SomeInstr . ReadRegister r+  writeRegister r = SomeInstr . WriteRegister r
src/Symantic/Parser/Machine/Program.hs view
@@ -1,32 +1,33 @@ {-# LANGUAGE ConstraintKinds #-}+{-# LANGUAGE TupleSections #-} {-# LANGUAGE UndecidableInstances #-} -- For Cursorable (Cursor inp) -- | Build the 'Instr'uction 'Program' of a 'Machine' -- from the 'Comb'inators of a 'Grammar'. -- 'Instr'uctions are kept introspectable--- to enable more optimizations now possible because+-- to enable more optimizations made possible now because -- of a broader knowledge of the 'Instr'uctions around--- those generated (eg. by using 'joinNext').+-- those generated (see for instance 'joinNext'). module Symantic.Parser.Machine.Program where -import Control.Monad (Monad(..), (<=<), (=<<), liftM, liftM2, sequence)-import Data.Function (($))-import System.IO (IO)-import Type.Reflection (Typeable) import Control.DeepSeq (NFData)+import Control.Monad (Monad(..), (<=<), (=<<), liftM, liftM2, sequence) import Data.Bool (Bool(..)) import Data.Eq (Eq)+import Data.Function (($)) import Data.Function ((.)) import Data.Ord (Ord)+import Data.Semigroup (Semigroup(..))+import System.IO (IO) import Text.Show (Show(..))+import Type.Reflection (Typeable) import qualified Data.Functor as Functor-import qualified Data.HashMap.Strict as HM import qualified Data.Set as Set import qualified Data.Traversable as Traversable import qualified Language.Haskell.TH as TH import qualified Language.Haskell.TH.Syntax as TH-import qualified Symantic.Typed.Lang as Prod+import qualified Symantic.Lang as Prod -import Symantic.Typed.Derive+import Symantic.Derive import Symantic.Parser.Grammar import Symantic.Parser.Machine.Input import Symantic.Parser.Machine.Instructions@@ -39,10 +40,10 @@ -- the next 'Instr'uction. data Program repr inp a = Program { unProgram ::   forall vs ret.-  -- This is the next instruction+  -- This is the next instruction.   SomeInstr repr inp (a ': vs) ret ->   -- This is the current instruction-  -- IO is needed for 'TH.newName' in 'joinNext'.+  -- IO is needed for 'TH.newName'.   IO (SomeInstr repr inp vs ret)   } @@ -58,12 +59,15 @@ -- | All the 'Instr'uctions. type Machinable tok repr =   ( InstrBranchable repr+  , InstrComment repr   , InstrExceptionable repr   , InstrInputable repr   , InstrJoinable repr   , InstrCallable repr   , InstrValuable repr   , InstrReadable tok repr+  , InstrIterable repr+  , InstrRegisterable repr   , Eq tok   , Ord tok   , TH.Lift tok@@ -75,28 +79,7 @@ instance   ( Cursorable (Cursor inp)   , InstrBranchable repr-  , InstrExceptionable repr-  , InstrInputable repr-  , InstrJoinable repr-  , InstrValuable repr-  , InstrReadable (InputToken inp) repr-  , Typeable (InputToken inp)-  ) =>-  Derivable (Comb CombAlternable (Program repr inp)) where-  derive = \case-    Alt ExceptionFailure-      (Comb (SatisfyOrFail _fs p :: Comb (CombSatisfiable (InputToken inp)) (Program repr inp) a))-      (Comb (Failure sf)) ->-      satisfyOrFail (Set.singleton sf) p-    Alt exn x y -> alt exn (derive x) (derive y)-    Empty -> empty-    Failure sf -> failure sf-    Throw exn -> throw exn-    Try x -> try (derive x)--instance-  ( Cursorable (Cursor inp)-  , InstrBranchable repr+  , InstrComment repr   , InstrExceptionable repr   , InstrInputable repr   , InstrJoinable repr@@ -105,32 +88,37 @@   alt exn (Program l) (Program r) = joinNext $ Program $ \next ->     liftM2 (catch exn)       (l (commit exn next))-      (failIfConsumed exn Functor.<$> r next)+      (raiseAgainIfConsumed exn Functor.<$> r next)   throw exn = Program $ \_next -> return $ raise exn   failure flr = Program $ \_next -> return $ fail (Set.singleton flr)   empty = Program $ \_next -> return $ fail (Set.singleton (SomeFailure FailureEmpty))   try (Program x) = Program $ \next ->     liftM2 (catch ExceptionFailure)       (x (commit ExceptionFailure next))-      -- On exception, reset the input, and propagate the failure.+      -- On 'ExceptionFailure', reset the input, and propagate the failure.       (return $ loadInput $ fail Set.empty) --- | If no input has been consumed by the failing alternative--- then continue with the given continuation.--- Otherwise, propagate the failure.-failIfConsumed ::+-- | @(raiseAgainIfConsumed exn ok)@+-- compares the stacked input position with the current one,+-- in case they're the same then continue with @(ok)@,+-- otherwise, re-'raise' @(exn)@,+-- without updating the farthest error+-- (which is usually done when 'fail'ing).+raiseAgainIfConsumed ::   Cursorable (Cursor inp) =>   InstrBranchable repr =>+  InstrComment repr =>   InstrExceptionable repr =>   InstrInputable repr =>   InstrValuable repr =>   Exception ->   SomeInstr repr inp vs ret ->   SomeInstr repr inp (Cursor inp ': vs) ret-failIfConsumed exn k =-  pushInput $+raiseAgainIfConsumed exn ok =+  comment "raiseAgainIfConsumed" $+  saveInput $   lift2Value (splice sameOffset) $-  ifBranch k $+  ifBranch ok $     case exn of       ExceptionLabel lbl -> raise lbl       ExceptionFailure -> fail Set.empty@@ -180,36 +168,62 @@ instance   ( Cursorable (Cursor inp)   , InstrBranchable repr+  , InstrCallable repr+  , InstrComment repr   , InstrExceptionable repr   , InstrInputable repr+  , InstrIterable repr   , InstrJoinable repr+  , InstrRegisterable repr   , InstrValuable repr   ) => CombFoldable (Program repr inp) where-  {--  chainPre op p = go <*> p-    where go = (Prod..) <$> op <*> go <|> pure Prod.id-  chainPost p op = p <**> go-    where go = (Prod..) <$> op <*> go <|> pure Prod.id-  -}+  chainPre (Program op) (Program done) =+    new (pure Prod.id) $ \(Register r) -> Program $ \next -> do+      !loopName <- TH.newName "loop"+      liftM2 (iter (LetName loopName))+        (op $+          mapValue (Prod.flip Prod..@ (Prod..)) $+          modifyRegister r $+          jump True (LetName loopName) )+        (raiseAgainIfConsumed ExceptionFailure .+          readRegister r Functor.<$>+          (done (applyValue next)))+  chainPost (Program done) (Program op) =+    new (pure Prod.id) $ \(Register r) -> Program $ \next -> do+      !loopName <- TH.newName "loop"+      liftM2 (iter (LetName loopName))+        (op $+          modifyRegister (UnscopedRegister (unUnscopedRegister r)) $+          jump True (LetName loopName) )+        (raiseAgainIfConsumed ExceptionFailure .+          readRegister r Functor.<$>+          (done (applyValue next))) instance   InstrCallable repr =>-  Letable TH.Name (Program repr inp) where-  shareable n (Program sub) = Program $ \next -> do-    sub' <- sub ret-    return $ defLet (HM.singleton n (SomeLet sub')) (call (LetName n) next)-  ref _isRec n = Program $ \case+  Referenceable TH.Name (Program repr inp) where+  -- TODO: isRec should be passed to 'call' and 'jump'+  -- instead of redoing the work with 'CallTrace'.+  ref isRec name = Program $ \case     -- Tail Call Optimization:     -- returning just after a 'call' is useless:     -- using 'jump' lets the 'ret' of the 'defLet'     -- directly return where it would in two 'ret's.-    Instr Ret{} -> return $ jump (LetName n)-    next -> return $ call (LetName n) next+    Instr Ret{} -> return $ jump isRec (LetName name)+    next -> return $ call isRec (LetName name) next+  {-+  refable n (Program sub) = Program $ \next -> do+    sub' <- sub ret+    return $ defLet (HM.singleton n (SomeLet sub')) (call (LetName n) next)+  -} instance   InstrCallable repr =>   Letsable TH.Name (Program repr inp) where-  lets defs (Program x) = Program $ \next -> do-    defs' <- Traversable.traverse (\(SomeLet (Program val)) -> liftM SomeLet (val ret)) defs-    liftM (defLet defs') (x next)+  lets defs (Program body) = Program $ \next -> do+    -- Every definition becomes a 'call'able subroutine.+    defs' <- Traversable.traverse+      (\(SomeLet (Program val)) -> liftM SomeLet (val ret))+      defs+    liftM (defLet defs') (body next) instance   ( Eq (InputToken inp)   , Cursorable (Cursor inp)@@ -220,13 +234,18 @@   , InstrReadable (InputToken inp) repr   , Typeable (InputToken inp)   , InstrValuable repr+  , InstrComment repr   ) => CombLookable (Program repr inp) where   look (Program x) = Program $ \next ->-    liftM pushInput (x (swapValue (loadInput next)))-  eof = negLook (satisfy (Prod.const Prod..@ Prod.bool True))-        -- This sets a better failure message-        <|> (Program $ \_next -> return $ fail (Set.singleton (SomeFailure FailureEnd)))+    liftM (comment "look") $+    liftM saveInput (x (swapValue (loadInput next)))+  eof =+    negLook (satisfy (Prod.const Prod..@ Prod.bool True))+      -- This sets a better failure message+      <|> (Program $ \_next ->+        return $ comment "eof.fail" $ fail (Set.singleton (SomeFailure FailureEnd)))   negLook (Program x) = Program $ \next ->+    liftM (comment "negLook") $     liftM2 (catch ExceptionFailure)       -- On x success, discard the result,       -- and replace this 'Catcher' by a failure whose 'farthestExpecting' is negated,@@ -239,27 +258,35 @@       --   the grammar might be blamed on something in x       --   that, if corrected, still makes x succeed       --   and (negLook x) fail.-      (liftM pushInput $ x $+      (+        liftM (comment "negLook.ahead") $+        liftM saveInput $ x $         popValue $ commit ExceptionFailure $-          loadInput $ fail Set.empty)+          loadInput $ fail Set.empty+      )       -- On x failure, reset the input,       -- and go on with the next 'Instr'uctions.-      (return $ loadInput $ pushValue Prod.unit next)+      (+        liftM (comment "negLook.reset") $+        return $ loadInput $ pushValue Prod.unit next+      ) instance   ( InstrBranchable repr   , InstrJoinable repr   ) => CombMatchable (Program repr inp) where-  conditional (Program a) ps bs (Program d) = joinNext $ Program $ \next -> do-    bs' <- Control.Monad.sequence $ (\(Program b) -> b next) Functor.<$> bs-    a =<< liftM (choicesBranch (prodCode Functor.<$> ps) bs') (d next)+  conditional (Program a) bs (Program d) = joinNext $ Program $ \next -> do+    bs' <- Control.Monad.sequence $ (\(p, b) -> (prodCode p,) Functor.<$> unProgram b next) Functor.<$> bs+    a =<< liftM (choicesBranch bs') (d next) instance   ( tok ~ InputToken inp   , InstrReadable tok repr+  , InstrComment repr   , Typeable tok   ) => CombSatisfiable tok (Program repr inp) where-  -- Note: 'read' is left with the responsability-  -- to apply 'normalOrderReduction' if need be.-  satisfyOrFail fs p = Program $ return . read fs (prodCode p)+  satisfyOrFail fs p = Program $ \next ->+    return $+      comment ("satisfy "<>showsPrec 11 (prodCode p) "") $+      read fs (prodCode p) next instance   ( InstrBranchable repr   , InstrJoinable repr@@ -269,3 +296,24 @@     lr =<< liftM2 caseBranch       (l (swapValue (applyValue next)))       (r (swapValue (applyValue next)))+instance+  ( InstrValuable repr+  , InstrRegisterable repr+  ) => CombRegisterable (Program repr inp) where+  new (Program p) k = Program $ \next -> do+    !regName <- TH.newName "reg"+    p =<< liftM (newRegister (UnscopedRegister regName))+      (unProgram (k (Register (UnscopedRegister regName))) next)+  get (Register r) = Program $ \next ->+    return $ readRegister r next+  put (Register r) (Program k) = Program $ \next ->+    k $ writeRegister r $ pushValue Prod.unit next+instance+  ( InstrValuable repr+  , InstrRegisterable repr+  ) => CombRegisterableUnscoped (Program repr inp) where+  newUnscoped r (Program p) k = Program $ \next ->+    p =<< liftM (newRegister r) (unProgram k next)+  getUnscoped r = Program $ return . readRegister r+  putUnscoped r (Program k) = Program $+    k . writeRegister r . pushValue Prod.unit
src/Symantic/Parser/Machine/View.hs view
@@ -1,5 +1,6 @@+{-# LANGUAGE AllowAmbiguousTypes #-} {-# LANGUAGE OverloadedStrings #-}-{-# LANGUAGE UndecidableInstances #-} -- For ShowLetName+{-# LANGUAGE UndecidableInstances #-} -- For HideableName module Symantic.Parser.Machine.View where  import Data.Bool (Bool(..))@@ -17,46 +18,51 @@ import qualified Data.Map.Strict as Map import qualified Data.Set as Set import qualified Data.Tree as Tree+import Language.Haskell.TH.HideName import qualified Language.Haskell.TH.Syntax as TH import Prelude (error) -import Symantic.Parser.Grammar.ObserveSharing (ShowLetName(..))+import Symantic.Optimize (normalOrderReduction)+import Symantic.Parser.Grammar.Combinators (UnscopedRegister(..))+import Symantic.Parser.Grammar.ObserveSharing import Symantic.Parser.Machine.Instructions-import Symantic.Typed.ObserveSharing (SomeLet(..)) import Symantic.Parser.Machine.Generate  -- * Type 'ViewMachine' data ViewMachine (showName::Bool) inp (vs:: [Type]) a   =  ViewMachine   { viewGen :: Gen inp vs a-    -- ^ Provide 'GenAnalysis', which next important for debugging+    -- ^ Provide 'GenAnalysis', which is important for debugging     -- and improving golden tests, see 'viewInstrCmd'.   , unViewMachine ::-      CallTrace ->-      LetMap GenAnalysis -> -- Output of 'runGenAnalysis'.+      LetRecs TH.Name GenAnalysis -> -- Output of 'mutualFix'.       Tree.Forest (String, String) ->       Tree.Forest (String, String)   } -viewMachine ::-  ViewMachine sN inp vs a ->-  ViewMachine sN inp vs a+viewMachine :: ViewMachine sN inp vs a -> ViewMachine sN inp vs a viewMachine = id +showSplice :: Splice a -> String+showSplice p = showsPrec 10 (normalOrderReduction p) ""+ -- | Helper to view a command. viewInstrCmd ::+  forall (sN::Bool) inp vs a.+  HideableName sN =>   Either TH.Name (Gen inp vs a) ->-  CallTrace ->-  LetMap GenAnalysis ->+  LetRecs TH.Name GenAnalysis ->   (String, String) -> Tree.Forest (String, String) -> Tree.Tree (String, String)-viewInstrCmd gen ct lm (n, no) = Tree.Node $ (n+viewInstrCmd gen finalByLet (cmd, no) = Tree.Node $ (cmd   <> "\nminReads="<>showsPrec 11 (minReads ga) ""-  <> "\nmayRaise="<>showsPrec 11 (Map.keys (mayRaise ga)) ""+  <> "\nmayRaise="<>show (Map.keys (mayRaise ga))+  <> "\nalwaysRaise="<>show (Set.toList (alwaysRaise ga))+  <> "\nfreeRegs="<>show (hideableName @sN (Set.toList (freeRegs ga)))   , no)   where   ga = case gen of-         Right r -> (\f -> f ct) $ genAnalysis r $ (\f _ct -> f) <$> lm-         Left l -> HM.findWithDefault (error (show (l, HM.keys lm))) l lm+         Right a -> genAnalysis a finalByLet+         Left n -> HM.findWithDefault (error (show (n, HM.keys finalByLet))) n finalByLet  -- | Helper to view an argument. viewInstrArg :: String -> Tree.Forest (String, String) -> Tree.Tree (String, String)@@ -64,7 +70,7 @@  instance Show (ViewMachine sN inp vs a) where   show vm = List.unlines $ drawTrees $-      unViewMachine vm [] (runGenAnalysis (genAnalysisByLet (viewGen vm))) []+      unViewMachine vm (mutualFix (genAnalysisByLet (viewGen vm))) []     where     draw :: Tree.Tree (String, String) -> [String]     draw (Tree.Node (x, n) ts0) =@@ -75,136 +81,189 @@     drawTrees (t:ts) = draw t <> drawTrees ts     shift ind0 ind = List.zipWith (<>) (ind0 : List.repeat ind) -instance InstrValuable (ViewMachine sN) where+instance+  HideableName sN =>+  InstrComment (ViewMachine sN) where+  comment msg k = ViewMachine +    { unViewMachine = \lm next ->+        viewInstrCmd @sN (Right gen) lm ("comment "<>show msg, "") [] :+        unViewMachine k lm next+    , viewGen = gen+    } where gen = comment msg (viewGen k)+instance+  HideableName sN =>+  InstrValuable (ViewMachine sN) where   pushValue a k = ViewMachine-    { unViewMachine = \ct lm next ->-        viewInstrCmd (Right gen) ct lm ("pushValue "<>showsPrec 10 a "", "") [] :-        unViewMachine k ct lm next+    { unViewMachine = \lm next ->+        viewInstrCmd @sN (Right gen) lm ("pushValue "<>showSplice a, "") [] :+        unViewMachine k lm next     , viewGen = gen     } where gen = pushValue a (viewGen k)   popValue k = ViewMachine-    { unViewMachine = \ct lm next ->-        viewInstrCmd (Right gen) ct lm ("popValue", "") [] :-        unViewMachine k ct lm next+    { unViewMachine = \lm next ->+        viewInstrCmd @sN (Right gen) lm ("popValue", "") [] :+        unViewMachine k lm next     , viewGen = gen     } where gen = popValue (viewGen k)   lift2Value f k = ViewMachine-    { unViewMachine = \ct lm next ->-        viewInstrCmd (Right gen) ct lm ("lift2Value "<>showsPrec 10 f "", "") [] :-        unViewMachine k ct lm next+    { unViewMachine = \lm next ->+        viewInstrCmd @sN (Right gen) lm ("lift2Value "<>showSplice f, "") [] :+        unViewMachine k lm next     , viewGen = gen     } where gen = lift2Value f (viewGen k)   swapValue k = ViewMachine-    { unViewMachine = \ct lm next ->-        viewInstrCmd (Right gen) ct lm ("swapValue", "") [] :-        unViewMachine k ct lm next+    { unViewMachine = \lm next ->+        viewInstrCmd @sN (Right gen) lm ("swapValue", "") [] :+        unViewMachine k lm next     , viewGen = gen     } where gen = swapValue (viewGen k)-instance InstrExceptionable (ViewMachine sN) where+instance+  HideableName sN =>+  InstrExceptionable (ViewMachine sN) where   raise exn = ViewMachine-    { unViewMachine = \ct lm next ->-        viewInstrCmd (Right gen) ct lm ("raise "<>show exn, "") [] : next+    { unViewMachine = \lm next ->+        viewInstrCmd @sN (Right gen) lm ("raise "<>show exn, "") [] : next     , viewGen = gen     } where gen = raise exn-  fail flr = ViewMachine-    { unViewMachine = \ct lm next ->-        viewInstrCmd (Right gen) ct lm ("fail "<>show (Set.toList flr), "") [] : next+  fail fs = ViewMachine+    { unViewMachine = \lm next ->+        viewInstrCmd @sN (Right gen) lm ("fail "<>show (Set.toList fs), "") [] : next     , viewGen = gen-    } where gen = fail flr+    } where gen = fail fs   commit exn k = ViewMachine-    { unViewMachine = \ct lm next ->-        viewInstrCmd (Right gen) ct lm ("commit "<>show exn, "") [] :-        unViewMachine k ct lm next+    { unViewMachine = \lm next ->+        viewInstrCmd @sN (Right gen) lm ("commit "<>show exn, "") [] :+        unViewMachine k lm next     , viewGen = gen     } where gen = commit exn (viewGen k)   catch exn ok ko = ViewMachine-    { unViewMachine = \ct lm next ->-        viewInstrCmd (Right gen) ct lm ("catch "<>show exn, "")-          [ viewInstrArg "ok" (unViewMachine ok ct lm [])-          , viewInstrArg "ko" (unViewMachine ko ct lm [])+    { unViewMachine = \lm next ->+        viewInstrCmd @sN (Right gen) lm ("catch "<>show exn, "")+          [ viewInstrArg "catchScope" (unViewMachine ok lm [])+          , viewInstrArg ("onException "<>show exn) (unViewMachine ko lm [])           ] : next     , viewGen = gen     } where gen = catch exn (viewGen ok) (viewGen ko)-instance InstrBranchable (ViewMachine sN) where+instance+  HideableName sN =>+  InstrBranchable (ViewMachine sN) where   caseBranch l r = ViewMachine-    { unViewMachine = \ct lm next ->-        viewInstrCmd (Right gen) ct lm ("case", "")-          [ viewInstrArg "left" (unViewMachine l ct lm [])-          , viewInstrArg "right" (unViewMachine r ct lm [])+    { unViewMachine = \lm next ->+        viewInstrCmd @sN (Right gen) lm ("case", "")+          [ viewInstrArg "left" (unViewMachine l lm [])+          , viewInstrArg "right" (unViewMachine r lm [])           ] : next     , viewGen = gen     } where gen = caseBranch (viewGen l) (viewGen r)-  choicesBranch ps bs d = ViewMachine-    { unViewMachine = \ct lm next ->-        viewInstrCmd (Right gen) ct lm ("choicesBranch "<>show ps, "") (-          ((\b -> viewInstrArg "branch" $ unViewMachine b ct lm []) <$> bs) <>-          [ viewInstrArg "default" (unViewMachine d ct lm []) ]+  choicesBranch bs d = ViewMachine+    { unViewMachine = \lm next ->+        viewInstrCmd @sN (Right gen) lm ("choicesBranch", "") (+          ((\(p, b) -> viewInstrArg ("branch "<>showSplice p) $+            unViewMachine b lm []) <$> bs) <>+          [ viewInstrArg "default" (unViewMachine d lm []) ]         ) : next     , viewGen = gen-    } where gen = choicesBranch ps (viewGen <$> bs) (viewGen d)+    } where gen = choicesBranch ((viewGen <$>) <$> bs) (viewGen d) instance-  ShowLetName sN TH.Name =>+  HideableName sN =>   InstrCallable (ViewMachine sN) where   defLet defs k = ViewMachine-    { unViewMachine = \ct lm next ->-        (<> unViewMachine k ct lm next) $+    { unViewMachine = \lm next ->+        (<> unViewMachine k lm next) $         List.sortBy (compare `on` (((fst <$>) <$>) . Tree.levels)) $         ((\(n, SomeLet sub) ->-          viewInstrCmd (Left n) ct lm-            ("let", " "<>showLetName @sN n)-            (unViewMachine sub ct lm []))+          viewInstrCmd @sN (Left n) lm+            ("let", " "<>show (hideableName @sN n))+            (unViewMachine sub lm []))           <$> HM.toList defs)     , viewGen = gen     } where gen = defLet ((\(SomeLet x) -> SomeLet (viewGen x)) <$> defs) (viewGen k)-  jump ln@(LetName n) = ViewMachine-    { unViewMachine = \ct lm next ->-        viewInstrCmd (Right gen) ct lm ("jump", " "<>showLetName @sN n) [] : next+  jump isRec ln@(LetName n) = ViewMachine+    { unViewMachine = \lm next ->+        viewInstrCmd @sN (Right gen) lm ("jump", " "<>show (hideableName @sN n)) [] : next     , viewGen = gen-    } where gen = jump ln-  call ln@(LetName n) k = ViewMachine-    { unViewMachine = \ct lm next ->-        viewInstrCmd (Right gen) ct lm ("call", " "<>showLetName @sN n) [] :-        unViewMachine k (n:ct) lm next+    } where gen = jump isRec ln+  call isRec ln@(LetName n) k = ViewMachine+    { unViewMachine = \lm next ->+        viewInstrCmd @sN (Right gen) lm ("call", " "<>show (hideableName @sN n)) [] :+        unViewMachine k lm next     , viewGen = gen-    } where gen = call ln (viewGen k)+    } where gen = call isRec ln (viewGen k)   ret = ViewMachine-    { unViewMachine = \ct lm next ->-        viewInstrCmd (Right gen) ct lm ("ret", "") [] : next+    { unViewMachine = \lm next ->+        viewInstrCmd @sN (Right gen) lm ("ret", "") [] : next     , viewGen = gen     } where gen = ret instance-  ShowLetName sN TH.Name =>+  HideableName sN =>   InstrJoinable (ViewMachine sN) where-  defJoin ln@(LetName n) j k = ViewMachine-    { unViewMachine = \ct lm next ->-        viewInstrCmd (Left n) ct lm-          ("join", " "<>showLetName @sN n)-          (unViewMachine j ct lm []) :-        unViewMachine k (n:ct) lm next+  defJoin ln@(LetName n) sub k = ViewMachine+    { unViewMachine = \lm next ->+        viewInstrCmd @sN (Left n) lm+          ("join", " "<>show (hideableName @sN n))+          (unViewMachine sub lm []) :+        unViewMachine k lm next     , viewGen = gen-    } where gen = defJoin ln (viewGen j) (viewGen k)+    } where gen = defJoin ln (viewGen sub) (viewGen k)   refJoin ln@(LetName n) = ViewMachine-    { unViewMachine = \ct lm next ->-        viewInstrCmd (Right gen) ct lm ("refJoin", " "<>showLetName @sN n) [] : next+    { unViewMachine = \lm next ->+        viewInstrCmd @sN (Right gen) lm ("refJoin", " "<>show (hideableName @sN n)) [] : next     , viewGen = gen     } where gen = refJoin ln-instance InstrInputable (ViewMachine sN) where-  pushInput k = ViewMachine-    { unViewMachine = \ct lm next ->-        viewInstrCmd (Right gen) ct lm ("pushInput", "") [] :-        unViewMachine k ct lm next+instance+  HideableName sN =>+  InstrInputable (ViewMachine sN) where+  saveInput k = ViewMachine+    { unViewMachine = \lm next ->+        viewInstrCmd @sN (Right gen) lm ("saveInput", "") [] :+        unViewMachine k lm next     , viewGen = gen-    } where gen = pushInput (viewGen k)+    } where gen = saveInput (viewGen k)   loadInput k = ViewMachine-    { unViewMachine = \ct lm next ->-        viewInstrCmd (Right gen) ct lm ("loadInput", "") [] :-        unViewMachine k ct lm next+    { unViewMachine = \lm next ->+        viewInstrCmd @sN (Right gen) lm ("loadInput", "") [] :+        unViewMachine k lm next     , viewGen = gen     } where gen = loadInput (viewGen k)-instance InstrReadable tok Gen => InstrReadable tok (ViewMachine sN) where+instance+  ( HideableName sN+  , InstrReadable tok Gen+  ) => InstrReadable tok (ViewMachine sN) where   read es p k = ViewMachine-    { unViewMachine = \ct lm next ->-        viewInstrCmd (Right gen) ct lm ("read "<>showsPrec 10 p "", "") [] :-        unViewMachine k ct lm next+    { unViewMachine = \lm next ->+        viewInstrCmd @sN (Right gen) lm ("read "<>showSplice p, "") [] :+        unViewMachine k lm next     , viewGen = gen     } where gen = read es p (viewGen k)+instance+  HideableName sN =>+  InstrIterable (ViewMachine sN) where+  iter jumpName@(LetName n) ok ko = ViewMachine+    { unViewMachine = \lm next ->+        viewInstrCmd @sN (Right gen) lm ("iter", " "<>show (hideableName @sN n))+          [ viewInstrArg "ok" (unViewMachine ok lm [])+          , viewInstrArg "ko" (unViewMachine ko lm [])+          ] : next+    , viewGen = gen+    } where gen = iter jumpName (viewGen ok) (viewGen ko)+instance+  HideableName sN =>+  InstrRegisterable (ViewMachine sN) where+  newRegister reg@(UnscopedRegister r) k = ViewMachine+    { unViewMachine = \lm next ->+        viewInstrCmd @sN (Right gen) lm ("newRegister", " "<>show (hideableName @sN r)) [] :+        unViewMachine k lm next+    , viewGen = gen+    } where gen = newRegister reg (viewGen k)+  readRegister reg@(UnscopedRegister r) k = ViewMachine+    { unViewMachine = \lm next ->+        viewInstrCmd @sN (Right gen) lm ("readRegister", " "<>show (hideableName @sN r)) [] :+        unViewMachine k lm next+    , viewGen = gen+    } where gen = readRegister reg (viewGen k)+  writeRegister reg@(UnscopedRegister r) k = ViewMachine+    { unViewMachine = \lm next ->+        viewInstrCmd @sN (Right gen) lm ("writeRegister", " "<>show (hideableName @sN r)) [] :+        unViewMachine k lm next+    , viewGen = gen+    } where gen = writeRegister reg (viewGen k)
symantic-parser.cabal view
@@ -1,22 +1,26 @@ cabal-version: 3.0 name: symantic-parser-version: 0.2.0.20210703+maintainer: mailto:~julm/symantic-parser@todo.hut.sourcephile.fr+bug-reports: https://todo.hut.sourcephile.fr/~julm/symantic-parser+homepage: https://git.hut.sourcephile.fr/~julm/symantic-parser+author: Julien Moutinho <julm+symantic-parser@sourcephile.fr>+copyright: Julien Moutinho <julm+symantic-parser@sourcephile.fr>+license: AGPL-3.0-or-later+license-file: LICENSES/AGPL-3.0-or-later.txt+version: 0.2.1.20210803+stability: experimental synopsis: Parser combinators statically optimized and staged via typed meta-programming description:   This is a work-in-progress experimental library to generate parsers,   leveraging Tagless-Final interpreters and Typed Template Haskell staging.-  .+   This is an alternative but less powerful/reviewed   implementation of [ParsleyHaskell](https://github.com/J-mie6/ParsleyHaskell).   See the paper by Jamie Willis, Nicolas Wu, and Matthew Pickering,   admirably well presented at ICFP-2020: [Staged Selective Parser Combinators](https://icfp20.sigplan.org/details/icfp-2020-papers/20/Staged-Selective-Parser-Combinators).-license: AGPL-3.0-or-later-author: Julien Moutinho <julm+symantic-parser@sourcephile.fr>-maintainer: Julien Moutinho <julm+symantic-parser@sourcephile.fr>-bug-reports: https://mails.sourcephile.fr/inbox/symantic-parser-copyright: Julien Moutinho <julm+symantic-parser@sourcephile.fr>-stability: experimental category: Parsing+build-type: Simple+tested-with: GHC==9.0.1 extra-doc-files:   ChangeLog.md   Hacking.md@@ -31,14 +35,12 @@   Makefile   parsers/Parsers/Brainfuck/inputs/*.bf   shell.nix-  test/Golden/**/*.txt+  tests/Golden/**/*.txt extra-tmp-files:-build-type: Simple-tested-with: GHC==9.0.1  source-repository head   type: git-  location: git://git.sourcephile.fr/haskell/symantic-parser+  location: https://git.hut.sourcephile.fr/~julm/symantic-parser  flag dump-core   description: Dump GHC's Core in HTML@@ -109,7 +111,7 @@     hashable,     -- For Language.Haskell.Ppr.Lib.pprExp     pretty >= 1.1,-    symantic-base >= 0.1,+    symantic-base >= 0.2,     template-haskell >= 2.16,     text,     transformers,@@ -157,7 +159,7 @@     megaparsec >= 9.0,     process >= 1.6,     strict >= 0.4,-    symantic-base >= 0.1,+    symantic-base >= 0.2,     tasty >= 0.11,     tasty-golden >= 2.3,     template-haskell >= 2.16,@@ -165,11 +167,12 @@     transformers >= 0.4,     unix >= 2.7,     unordered-containers+  -- ghc-options: -ddump-splices -test-suite symantic-parser-test+test-suite symantic-parser-tests   import: boilerplate   type: exitcode-stdio-1.0-  hs-source-dirs: test+  hs-source-dirs: tests   main-is: Main.hs   other-modules:     Golden
− test/Golden.hs 
@@ -1,16 +0,0 @@-module Golden where--import Test.Tasty--import qualified Golden.Grammar-import qualified Golden.Machine-import qualified Golden.Parser-import qualified Golden.Splice--goldens :: TestTree-goldens = testGroup "Golden"-  [ Golden.Grammar.goldens-  , Golden.Machine.goldens-  , Golden.Parser.goldens-  , Golden.Splice.goldens-  ]
− test/Golden/Grammar.hs 
@@ -1,38 +0,0 @@-{-# LANGUAGE DataKinds #-} -- For using P.viewGrammar-{-# LANGUAGE Rank2Types #-}-{-# LANGUAGE TypeApplications #-}-module Golden.Grammar where--import Data.Bool (Bool(..))-import Control.Monad (Monad(..))-import Data.Function (($))-import Data.Semigroup (Semigroup(..))-import Data.String (IsString(..))-import Test.Tasty-import Test.Tasty.Golden-import Text.Show (Show(..))-import Data.Int (Int)-import qualified Data.List as List--import Golden.Utils-import qualified Symantic.Parser as P-import qualified Grammar--goldens :: TestTree-goldens = testGroup "Grammar" $-  [ testGroup "ViewGrammar" $-    (\f -> List.zipWith f Grammar.grammars [1::Int ..]) $ \gram g ->-    let grammarFile = getGoldenDir $ "Grammar/ViewGrammar/G"<>show g<>".expected.txt" in-    goldenVsStringDiff ("G"<>show g) goldenDiff grammarFile $ do-      resetTHNameCounter-      return $ fromString $ show $-        P.viewGrammar @'False gram-  , testGroup "OptimizeGrammar" $-    (\f -> List.zipWith f Grammar.grammars [1::Int ..]) $ \gram g ->-    let grammarFile = getGoldenDir $ "Grammar/OptimizeGrammar/G"<>show g<>".expected.txt" in-    goldenVsStringDiff ("G"<>show g) goldenDiff grammarFile $ do-      resetTHNameCounter-      return $ fromString $ show $-        P.viewGrammar @'False $-        P.optimizeGrammar gram-  ]
− test/Golden/Grammar/OptimizeGrammar/G1.expected.txt 
@@ -1,4 +0,0 @@-lets-` <*>-  + pure (\x_0 -> GHC.Show.show 'a')-  ` satisfy
− test/Golden/Grammar/OptimizeGrammar/G10.expected.txt 
@@ -1,10 +0,0 @@-lets-` <*>-  + pure GHC.Show.show-  ` <|>-    + <*>-    | + pure (\x_0 -> 'a')-    | ` satisfy-    ` <*>-      + pure (\x_0 -> 'b')-      ` satisfy
− test/Golden/Grammar/OptimizeGrammar/G11.expected.txt 
@@ -1,14 +0,0 @@-lets-+ let <hidden>-| ` <|>-|   + <*>-|   | + <*>-|   | | + pure (\x_0 -> \x_1 -> \x_2 -> (GHC.Types.:) 'a' (x_1 x_2))-|   | | ` satisfy-|   | ` rec <hidden>-|   ` pure (\x_0 -> x_0)-` <*>-  + <*>-  | + pure (\x_0 -> \x_1 -> GHC.Show.show (x_0 GHC.Types.[]))-  | ` ref <hidden>-  ` satisfy
− test/Golden/Grammar/OptimizeGrammar/G12.expected.txt 
@@ -1,14 +0,0 @@-lets-+ let <hidden>-| ` <|>-|   + <*>-|   | + <*>-|   | | + pure (\x_0 -> \x_1 -> \x_2 -> (GHC.Types.:) x_0 (x_1 x_2))-|   | | ` satisfy-|   | ` rec <hidden>-|   ` pure (\x_0 -> x_0)-` <*>-  + <*>-  | + pure (\x_0 -> \x_1 -> GHC.Show.show (x_0 GHC.Types.[]))-  | ` ref <hidden>-  ` eof
− test/Golden/Grammar/OptimizeGrammar/G13.expected.txt 
@@ -1,63 +0,0 @@-lets-+ let <hidden>-| ` <*>-|   + pure (\x_0 -> GHC.Tuple.())-|   ` ref <hidden>-+ let <hidden>-| ` <*>-|   + pure (\x_0 -> x_0 GHC.Types.[])-|   ` ref <hidden>-+ let <hidden>-| ` <|>-|   + <*>-|   | + <*>-|   | | + <*>-|   | | | + pure (\x_0 -> \x_1 -> \x_2 -> \x_3 -> (GHC.Types.:) x_0 (x_2 x_3))-|   | | | ` conditional-|   | | |   + look-|   | | |   | ` satisfy-|   | | |   + branches-|   | | |   | + <*>-|   | | |   | | + pure (\x_0 -> Parsers.Brainfuck.Types.Backward)-|   | | |   | | ` satisfy-|   | | |   | + <*>-|   | | |   | | + pure (\x_0 -> Parsers.Brainfuck.Types.Forward)-|   | | |   | | ` satisfy-|   | | |   | + <*>-|   | | |   | | + pure (\x_0 -> Parsers.Brainfuck.Types.Increment)-|   | | |   | | ` satisfy-|   | | |   | + <*>-|   | | |   | | + pure (\x_0 -> Parsers.Brainfuck.Types.Decrement)-|   | | |   | | ` satisfy-|   | | |   | + <*>-|   | | |   | | + pure (\x_0 -> Parsers.Brainfuck.Types.Input)-|   | | |   | | ` satisfy-|   | | |   | + <*>-|   | | |   | | + pure (\x_0 -> Parsers.Brainfuck.Types.Output)-|   | | |   | | ` satisfy-|   | | |   | ` <*>-|   | | |   |   + <*>-|   | | |   |   | + <*>-|   | | |   |   | | + <*>-|   | | |   |   | | | + pure (\x_0 -> \x_1 -> \x_2 -> \x_3 -> Parsers.Brainfuck.Types.Loop x_2)-|   | | |   |   | | | ` satisfy-|   | | |   |   | | ` ref <hidden>-|   | | |   |   | ` rec <hidden>-|   | | |   |   ` satisfy-|   | | |   ` failure-|   | | ` ref <hidden>-|   | ` rec <hidden>-|   ` pure (\x_0 -> x_0)-+ let <hidden>-| ` <|>-|   + <*>-|   | + <*>-|   | | + pure (\x_0 -> \x_1 -> \x_2 -> x_1 x_2)-|   | | ` satisfy-|   | ` rec <hidden>-|   ` pure (\x_0 -> x_0)-` <*>-  + <*>-  | + pure (\x_0 -> \x_1 -> GHC.Show.show x_1)-  | ` ref <hidden>-  ` ref <hidden>
− test/Golden/Grammar/OptimizeGrammar/G14.expected.txt 
@@ -1,410 +0,0 @@-lets-+ let <hidden>-| ` <*>-|   + <*>-|   | + pure (\x_0 -> \x_1 -> x_1)-|   | ` ref <hidden>-|   ` <|>-|     + <*>-|     | + pure (\x_0 -> GHC.Tuple.())-|     | ` ref <hidden>-|     ` ref <hidden>-+ let <hidden>-| ` <*>-|   + <*>-|   | + <*>-|   | | + <*>-|   | | | + pure (\x_0 -> \x_1 -> \x_2 -> \x_3 -> x_3)-|   | | | ` ref <hidden>-|   | | ` ref <hidden>-|   | ` ref <hidden>-|   ` ref <hidden>-+ let <hidden>-| ` <*>-|   + <*>-|   | + <*>-|   | | + <*>-|   | | | + <*>-|   | | | | + <*>-|   | | | | | + <*>-|   | | | | | | + pure (\x_0 -> \x_1 -> \x_2 -> \x_3 -> \x_4 -> \x_5 -> \x_6 -> x_4)-|   | | | | | | ` satisfy-|   | | | | | ` ref <hidden>-|   | | | | ` ref <hidden>-|   | | | ` ref <hidden>-|   | | ` ref <hidden>-|   | ` satisfy-|   ` ref <hidden>-+ let <hidden>-| ` <*>-|   + <*>-|   | + <*>-|   | | + <*>-|   | | | + <*>-|   | | | | + <*>-|   | | | | | + pure (\x_0 -> \x_1 -> \x_2 -> \x_3 -> \x_4 -> \x_5 -> GHC.Tuple.())-|   | | | | | ` satisfy-|   | | | | ` ref <hidden>-|   | | | ` ref <hidden>-|   | | ` ref <hidden>-|   | ` satisfy-|   ` ref <hidden>-+ let <hidden>-| ` <*>-|   + <*>-|   | + pure (\x_0 -> \x_1 -> '(')-|   | ` satisfy-|   ` ref <hidden>-+ let <hidden>-| ` <*>-|   + <*>-|   | + pure (\x_0 -> \x_1 -> ')')-|   | ` satisfy-|   ` ref <hidden>-+ let <hidden>-| ` <*>-|   + <*>-|   | + pure (\x_0 -> \x_1 -> ',')-|   | ` satisfy-|   ` ref <hidden>-+ let <hidden>-| ` <*>-|   + <*>-|   | + pure (\x_0 -> \x_1 -> ';')-|   | ` satisfy-|   ` ref <hidden>-+ let <hidden>-| ` <*>-|   + <*>-|   | + pure (\x_0 -> \x_1 -> GHC.Tuple.())-|   | ` ref <hidden>-|   ` ref <hidden>-+ let <hidden>-| ` <*>-|   + <*>-|   | + pure (\x_0 -> \x_1 -> x_1)-|   | ` satisfy-|   ` ref <hidden>-+ let <hidden>-| ` <*>-|   + <*>-|   | + pure (\x_0 -> \x_1 -> x_1)-|   | ` try-|   |   ` <*>-|   |     + <*>-|   |     | + <*>-|   |     | | + <*>-|   |     | | | + pure (\x_0 -> \x_1 -> \x_2 -> \x_3 -> x_3)-|   |     | | | ` satisfy-|   |     | | ` ref <hidden>-|   |     | ` ref <hidden>-|   |     ` ref <hidden>-|   ` ref <hidden>-+ let <hidden>-| ` <|>-|   + <*>-|   | + <*>-|   | | + pure (\x_0 -> \x_1 -> x_1)-|   | | ` <|>-|   | |   + <*>-|   | |   | + pure (\x_0 -> '0')-|   | |   | ` satisfy-|   | |   ` <*>-|   | |     + pure (\x_0 -> '1')-|   | |     ` satisfy-|   | ` ref <hidden>-|   ` <|>-|     + <*>-|     | + <*>-|     | | + <*>-|     | | | + <*>-|     | | | | + pure (\x_0 -> \x_1 -> \x_2 -> \x_3 -> x_1)-|     | | | | ` satisfy-|     | | | ` <|>-|     | | |   + <*>-|     | | |   | + <*>-|     | | |   | | + pure (\x_0 -> \x_1 -> x_1)-|     | | |   | | ` satisfy-|     | | |   | ` ref <hidden>-|     | | |   ` <*>-|     | | |     + <*>-|     | | |     | + <*>-|     | | |     | | + pure (\x_0 -> \x_1 -> \x_2 -> x_2)-|     | | |     | | ` satisfy-|     | | |     | ` satisfy-|     | | |     ` ref <hidden>-|     | | ` satisfy-|     | ` ref <hidden>-|     ` <*>-|       + <*>-|       | + pure (\x_0 -> \x_1 -> x_1)-|       | ` ref <hidden>-|       ` <|>-|         + <*>-|         | + pure (\x_0 -> GHC.Tuple.())-|         | ` <|>-|         |   + <*>-|         |   | + <*>-|         |   | | + <*>-|         |   | | | + pure (\x_0 -> \x_1 -> \x_2 -> x_1)-|         |   | | | ` ref <hidden>-|         |   | | ` <|>-|         |   | |   + <*>-|         |   | |   | + <*>-|         |   | |   | | + <*>-|         |   | |   | | | + <*>-|         |   | |   | | | | + pure (\x_0 -> \x_1 -> \x_2 -> \x_3 -> GHC.Tuple.())-|         |   | |   | | | | ` rec <hidden>-|         |   | |   | | | ` ref <hidden>-|         |   | |   | | ` ref <hidden>-|         |   | |   | ` ref <hidden>-|         |   | |   ` ref <hidden>-|         |   | ` ref <hidden>-|         |   ` ref <hidden>-|         ` ref <hidden>-+ let <hidden>-| ` <|>-|   + <*>-|   | + <*>-|   | | + <*>-|   | | | + <*>-|   | | | | + pure (\x_0 -> \x_1 -> \x_2 -> \x_3 -> \x_4 -> x_0 x_2 (x_3 x_4))-|   | | | | ` ref <hidden>-|   | | | ` ref <hidden>-|   | | ` rec <hidden>-|   | ` rec <hidden>-|   ` pure (\x_0 -> x_0)-+ let <hidden>-| ` <|>-|   + <*>-|   | + <*>-|   | | + <*>-|   | | | + <*>-|   | | | | + <*>-|   | | | | | + <*>-|   | | | | | | + <*>-|   | | | | | | | + <*>-|   | | | | | | | | + <*>-|   | | | | | | | | | + pure (\x_0 -> \x_1 -> \x_2 -> \x_3 -> \x_4 -> \x_5 -> \x_6 -> \x_7 -> \x_8 -> \x_9 -> x_8 x_9)-|   | | | | | | | | | ` try-|   | | | | | | | | |   ` <*>-|   | | | | | | | | |     + <*>-|   | | | | | | | | |     | + <*>-|   | | | | | | | | |     | | + <*>-|   | | | | | | | | |     | | | + <*>-|   | | | | | | | | |     | | | | + <*>-|   | | | | | | | | |     | | | | | + <*>-|   | | | | | | | | |     | | | | | | + <*>-|   | | | | | | | | |     | | | | | | | + pure (\x_0 -> \x_1 -> \x_2 -> \x_3 -> \x_4 -> \x_5 -> \x_6 -> \x_7 -> (GHC.Types.:) 'f' ((GHC.Types.:) 'u' ((GHC.Types.:) 'n' ((GHC.Types.:) 'c' ((GHC.Types.:) 't' ((GHC.Types.:) 'i' ((GHC.Types.:) 'o' ((GHC.Types.:) 'n' GHC.Types.[]))))))))-|   | | | | | | | | |     | | | | | | | ` satisfy-|   | | | | | | | | |     | | | | | | ` satisfy-|   | | | | | | | | |     | | | | | ` satisfy-|   | | | | | | | | |     | | | | ` satisfy-|   | | | | | | | | |     | | | ` satisfy-|   | | | | | | | | |     | | ` satisfy-|   | | | | | | | | |     | ` satisfy-|   | | | | | | | | |     ` satisfy-|   | | | | | | | | ` ref <hidden>-|   | | | | | | | ` ref <hidden>-|   | | | | | | ` ref <hidden>-|   | | | | | ` ref <hidden>-|   | | | | ` <|>-|   | | | |   + <*>-|   | | | |   | + <*>-|   | | | |   | | + <*>-|   | | | |   | | | + pure (\x_0 -> \x_1 -> \x_2 -> GHC.Tuple.())-|   | | | |   | | | ` satisfy-|   | | | |   | | ` ref <hidden>-|   | | | |   | ` ref <hidden>-|   | | | |   ` ref <hidden>-|   | | | ` ref <hidden>-|   | | ` ref <hidden>-|   | ` rec <hidden>-|   ` pure (\x_0 -> x_0)-+ let <hidden>-| ` <|>-|   + <*>-|   | + <*>-|   | | + <*>-|   | | | + <*>-|   | | | | + pure (\x_0 -> \x_1 -> \x_2 -> \x_3 -> \x_4 -> x_0 x_2 (x_3 x_4))-|   | | | | ` ref <hidden>-|   | | | ` ref <hidden>-|   | | ` ref <hidden>-|   | ` rec <hidden>-|   ` pure (\x_0 -> x_0)-+ let <hidden>-| ` <|>-|   + <*>-|   | + <*>-|   | | + <*>-|   | | | + <*>-|   | | | | + pure (\x_0 -> \x_1 -> \x_2 -> \x_3 -> \x_4 -> x_0 x_2 (x_3 x_4))-|   | | | | ` ref <hidden>-|   | | | ` ref <hidden>-|   | | ` ref <hidden>-|   | ` rec <hidden>-|   ` pure (\x_0 -> x_0)-+ let <hidden>-| ` <|>-|   + <*>-|   | + <*>-|   | | + <*>-|   | | | + <*>-|   | | | | + pure (\x_0 -> \x_1 -> \x_2 -> \x_3 -> \x_4 -> x_0 x_2 (x_3 x_4))-|   | | | | ` ref <hidden>-|   | | | ` ref <hidden>-|   | | ` ref <hidden>-|   | ` rec <hidden>-|   ` pure (\x_0 -> x_0)-+ let <hidden>-| ` <|>-|   + <*>-|   | + <*>-|   | | + <*>-|   | | | + <*>-|   | | | | + pure (\x_0 -> \x_1 -> \x_2 -> \x_3 -> \x_4 -> x_3 x_4)-|   | | | | ` satisfy-|   | | | ` ref <hidden>-|   | | ` ref <hidden>-|   | ` rec <hidden>-|   ` pure (\x_0 -> x_0)-+ let <hidden>-| ` <|>-|   + <*>-|   | + <*>-|   | | + pure (\x_0 -> \x_1 -> \x_2 -> x_1 x_2)-|   | | ` <|>-|   | |   + <*>-|   | |   | + <*>-|   | |   | | + pure (\x_0 -> \x_1 -> x_1)-|   | |   | | ` try-|   | |   | |   ` <*>-|   | |   | |     + <*>-|   | |   | |     | + pure (\x_0 -> \x_1 -> (GHC.Types.:) 'i' ((GHC.Types.:) 'f' GHC.Types.[]))-|   | |   | |     | ` satisfy-|   | |   | |     ` satisfy-|   | |   | ` ref <hidden>-|   | |   ` <|>-|   | |     + <*>-|   | |     | + <*>-|   | |     | | + <*>-|   | |     | | | + <*>-|   | |     | | | | + pure (\x_0 -> \x_1 -> \x_2 -> \x_3 -> x_3)-|   | |     | | | | ` try-|   | |     | | | |   ` <*>-|   | |     | | | |     + <*>-|   | |     | | | |     | + <*>-|   | |     | | | |     | | + <*>-|   | |     | | | |     | | | + <*>-|   | |     | | | |     | | | | + pure (\x_0 -> \x_1 -> \x_2 -> \x_3 -> \x_4 -> (GHC.Types.:) 'w' ((GHC.Types.:) 'h' ((GHC.Types.:) 'i' ((GHC.Types.:) 'l' ((GHC.Types.:) 'e' GHC.Types.[])))))-|   | |     | | | |     | | | | ` satisfy-|   | |     | | | |     | | | ` satisfy-|   | |     | | | |     | | ` satisfy-|   | |     | | | |     | ` satisfy-|   | |     | | | |     ` satisfy-|   | |     | | | ` ref <hidden>-|   | |     | | ` ref <hidden>-|   | |     | ` rec <hidden>-|   | |     ` <|>-|   | |       + try-|   | |       | ` <*>-|   | |       |   + <*>-|   | |       |   | + <*>-|   | |       |   | | + <*>-|   | |       |   | | | + <*>-|   | |       |   | | | | + <*>-|   | |       |   | | | | | + <*>-|   | |       |   | | | | | | + <*>-|   | |       |   | | | | | | | + <*>-|   | |       |   | | | | | | | | + <*>-|   | |       |   | | | | | | | | | + <*>-|   | |       |   | | | | | | | | | | + <*>-|   | |       |   | | | | | | | | | | | + pure (\x_0 -> \x_1 -> \x_2 -> \x_3 -> \x_4 -> \x_5 -> \x_6 -> \x_7 -> \x_8 -> \x_9 -> \x_10 -> \x_11 -> x_10)-|   | |       |   | | | | | | | | | | | ` <|>-|   | |       |   | | | | | | | | | | |   + <*>-|   | |       |   | | | | | | | | | | |   | + <*>-|   | |       |   | | | | | | | | | | |   | | + pure (\x_0 -> \x_1 -> GHC.Tuple.())-|   | |       |   | | | | | | | | | | |   | | ` try-|   | |       |   | | | | | | | | | | |   | |   ` <*>-|   | |       |   | | | | | | | | | | |   | |     + <*>-|   | |       |   | | | | | | | | | | |   | |     | + <*>-|   | |       |   | | | | | | | | | | |   | |     | | + pure (\x_0 -> \x_1 -> \x_2 -> (GHC.Types.:) 'v' ((GHC.Types.:) 'a' ((GHC.Types.:) 'r' GHC.Types.[])))-|   | |       |   | | | | | | | | | | |   | |     | | ` satisfy-|   | |       |   | | | | | | | | | | |   | |     | ` satisfy-|   | |       |   | | | | | | | | | | |   | |     ` satisfy-|   | |       |   | | | | | | | | | | |   | ` ref <hidden>-|   | |       |   | | | | | | | | | | |   ` ref <hidden>-|   | |       |   | | | | | | | | | | ` ref <hidden>-|   | |       |   | | | | | | | | | ` ref <hidden>-|   | |       |   | | | | | | | | ` ref <hidden>-|   | |       |   | | | | | | | ` ref <hidden>-|   | |       |   | | | | | | ` satisfy-|   | |       |   | | | | | ` ref <hidden>-|   | |       |   | | | | ` ref <hidden>-|   | |       |   | | | ` ref <hidden>-|   | |       |   | | ` ref <hidden>-|   | |       |   | ` ref <hidden>-|   | |       |   ` ref <hidden>-|   | |       ` <*>-|   | |         + <*>-|   | |         | + pure (\x_0 -> \x_1 -> x_0)-|   | |         | ` ref <hidden>-|   | |         ` ref <hidden>-|   | ` rec <hidden>-|   ` pure (\x_0 -> x_0)-+ let <hidden>-| ` <|>-|   + <*>-|   | + <*>-|   | | + pure (\x_0 -> \x_1 -> \x_2 -> x_1 x_2)-|   | | ` ref <hidden>-|   | ` rec <hidden>-|   ` pure (\x_0 -> x_0)-+ let <hidden>-| ` <|>-|   + <*>-|   | + <*>-|   | | + pure (\x_0 -> \x_1 -> \x_2 -> x_1 x_2)-|   | | ` ref <hidden>-|   | ` rec <hidden>-|   ` pure (\x_0 -> x_0)-+ let <hidden>-| ` <|>-|   + <*>-|   | + <*>-|   | | + pure (\x_0 -> \x_1 -> \x_2 -> x_1 x_2)-|   | | ` satisfy-|   | ` rec <hidden>-|   ` pure (\x_0 -> x_0)-+ let <hidden>-| ` <|>-|   + <*>-|   | + <*>-|   | | + <*>-|   | | | + <*>-|   | | | | + pure (\x_0 -> \x_1 -> \x_2 -> \x_3 -> GHC.Tuple.())-|   | | | | ` ref <hidden>-|   | | | ` ref <hidden>-|   | | ` ref <hidden>-|   | ` ref <hidden>-|   ` ref <hidden>-+ let <hidden>-| ` pure (\x_0 -> \x_1 -> x_1)-+ let <hidden>-| ` pure GHC.Tuple.()-+ let <hidden>-| ` pure GHC.Tuple.()-+ let <hidden>-| ` satisfy-` <*>-  + <*>-  | + <*>-  | | + <*>-  | | | + <*>-  | | | | + pure (\x_0 -> \x_1 -> \x_2 -> \x_3 -> \x_4 -> GHC.Show.show x_3)-  | | | | ` ref <hidden>-  | | | ` ref <hidden>-  | | ` ref <hidden>-  | ` ref <hidden>-  ` eof
− test/Golden/Grammar/OptimizeGrammar/G15.expected.txt 
@@ -1,12 +0,0 @@-lets-` <*>-  + <*>-  | + pure (\x_0 -> \x_1 -> GHC.Show.show x_0)-  | ` <|>-  |   + <*>-  |   | + pure (\x_0 -> 'a')-  |   | ` satisfy-  |   ` <*>-  |     + pure (\x_0 -> 'b')-  |     ` satisfy-  ` satisfy
− test/Golden/Grammar/OptimizeGrammar/G16.expected.txt 
@@ -1,16 +0,0 @@-lets-` <*>-  + <*>-  | + pure (\x_0 -> \x_1 -> GHC.Show.show x_0)-  | ` <|>-  |   + <*>-  |   | + pure (\x_0 -> 'a')-  |   | ` satisfy-  |   ` <|>-  |     + <*>-  |     | + pure (\x_0 -> 'b')-  |     | ` satisfy-  |     ` <*>-  |       + pure (\x_0 -> 'c')-  |       ` satisfy-  ` satisfy
− test/Golden/Grammar/OptimizeGrammar/G2.expected.txt 
@@ -1,11 +0,0 @@-lets-` <*>-  + pure GHC.Show.show-  ` try-    ` <*>-      + <*>-      | + <*>-      | | + pure (\x_0 -> \x_1 -> \x_2 -> (GHC.Types.:) 'a' ((GHC.Types.:) 'b' ((GHC.Types.:) 'c' GHC.Types.[])))-      | | ` satisfy-      | ` satisfy-      ` satisfy
− test/Golden/Grammar/OptimizeGrammar/G3.expected.txt 
@@ -1,12 +0,0 @@-lets-+ let <hidden>-| ` <|>-|   + <*>-|   | + <*>-|   | | + pure (\x_0 -> \x_1 -> \x_2 -> (GHC.Types.:) 'a' (x_1 x_2))-|   | | ` satisfy-|   | ` rec <hidden>-|   ` pure (\x_0 -> x_0)-` <*>-  + pure (\x_0 -> GHC.Show.show (x_0 GHC.Types.[]))-  ` ref <hidden>
− test/Golden/Grammar/OptimizeGrammar/G4.expected.txt 
@@ -1,25 +0,0 @@-lets-+ let <hidden>-| ` <|>-|   + <*>-|   | + <*>-|   | | + pure (\x_0 -> \x_1 -> \x_2 -> (GHC.Types.:) x_0 (x_1 x_2))-|   | | ` ref <hidden>-|   | ` rec <hidden>-|   ` pure (\x_0 -> x_0)-+ let <hidden>-| ` try-|   ` <*>-|     + <*>-|     | + <*>-|     | | + <*>-|     | | | + pure (\x_0 -> \x_1 -> \x_2 -> \x_3 -> (GHC.Types.:) 'a' ((GHC.Types.:) 'b' ((GHC.Types.:) 'c' ((GHC.Types.:) 'd' GHC.Types.[]))))-|     | | | ` satisfy-|     | | ` satisfy-|     | ` satisfy-|     ` satisfy-` <*>-  + <*>-  | + pure (\x_0 -> \x_1 -> GHC.Show.show ((GHC.Types.:) x_0 (x_1 GHC.Types.[])))-  | ` ref <hidden>-  ` ref <hidden>
− test/Golden/Grammar/OptimizeGrammar/G5.expected.txt 
@@ -1,27 +0,0 @@-lets-+ let <hidden>-| ` <|>-|   + <*>-|   | + <*>-|   | | + pure (\x_0 -> \x_1 -> \x_2 -> (GHC.Types.:) x_0 (x_1 x_2))-|   | | ` ref <hidden>-|   | ` rec <hidden>-|   ` pure (\x_0 -> x_0)-+ let <hidden>-| ` try-|   ` <*>-|     + <*>-|     | + <*>-|     | | + <*>-|     | | | + pure (\x_0 -> \x_1 -> \x_2 -> \x_3 -> (GHC.Types.:) 'a' ((GHC.Types.:) 'b' ((GHC.Types.:) 'c' ((GHC.Types.:) 'd' GHC.Types.[]))))-|     | | | ` satisfy-|     | | ` satisfy-|     | ` satisfy-|     ` satisfy-` <*>-  + <*>-  | + <*>-  | | + pure (\x_0 -> \x_1 -> \x_2 -> GHC.Show.show ((GHC.Types.:) x_0 (x_1 GHC.Types.[])))-  | | ` ref <hidden>-  | ` ref <hidden>-  ` eof
− test/Golden/Grammar/OptimizeGrammar/G6.expected.txt 
@@ -1,14 +0,0 @@-lets-` <*>-  + pure GHC.Show.show-  ` <|>-    + <*>-    | + <*>-    | | + pure (\x_0 -> \x_1 -> (GHC.Types.:) 'a' ((GHC.Types.:) 'a' GHC.Types.[]))-    | | ` satisfy-    | ` satisfy-    ` <*>-      + <*>-      | + pure (\x_0 -> \x_1 -> (GHC.Types.:) 'a' ((GHC.Types.:) 'b' GHC.Types.[]))-      | ` satisfy-      ` satisfy
− test/Golden/Grammar/OptimizeGrammar/G7.expected.txt 
@@ -1,16 +0,0 @@-lets-` <*>-  + pure GHC.Show.show-  ` <|>-    + try-    | ` <*>-    |   + <*>-    |   | + pure (\x_0 -> \x_1 -> (GHC.Types.:) 'a' ((GHC.Types.:) 'a' GHC.Types.[]))-    |   | ` satisfy-    |   ` satisfy-    ` try-      ` <*>-        + <*>-        | + pure (\x_0 -> \x_1 -> (GHC.Types.:) 'a' ((GHC.Types.:) 'b' GHC.Types.[]))-        | ` satisfy-        ` satisfy
− test/Golden/Grammar/OptimizeGrammar/G8.expected.txt 
@@ -1,14 +0,0 @@-lets-+ let <hidden>-| ` <|>-|   + <*>-|   | + <*>-|   | | + pure (\x_0 -> \x_1 -> \x_2 -> (GHC.Types.:) 'r' (x_1 x_2))-|   | | ` satisfy-|   | ` rec <hidden>-|   ` pure (\x_0 -> x_0)-` <*>-  + <*>-  | + pure (\x_0 -> \x_1 -> GHC.Show.show (x_0 GHC.Types.[]))-  | ` ref <hidden>-  ` eof
− test/Golden/Grammar/OptimizeGrammar/G9.expected.txt 
@@ -1,4 +0,0 @@-lets-` <*>-  + pure GHC.Show.show-  ` eof
− test/Golden/Grammar/ViewGrammar/G1.expected.txt 
@@ -1,8 +0,0 @@-lets-` <*>-  + pure GHC.Show.show-  ` <*>-    + <*>-    | + pure (\x_0 -> \x_1 -> x_0)-    | ` pure 'a'-    ` satisfy
− test/Golden/Grammar/ViewGrammar/G10.expected.txt 
@@ -1,14 +0,0 @@-lets-` <*>-  + pure GHC.Show.show-  ` <|>-    + <*>-    | + <*>-    | | + pure (\x_0 -> \x_1 -> x_0)-    | | ` pure 'a'-    | ` satisfy-    ` <*>-      + <*>-      | + pure (\x_0 -> \x_1 -> x_0)-      | ` pure 'b'-      ` satisfy
− test/Golden/Grammar/ViewGrammar/G11.expected.txt 
@@ -1,28 +0,0 @@-lets-+ let <hidden>-| ` <|>-|   + <*>-|   | + <*>-|   | | + pure (\x_0 -> \x_1 -> \x_2 -> x_0 (x_1 x_2))-|   | | ` <*>-|   | |   + pure (GHC.Types.:)-|   | |   ` <*>-|   | |     + <*>-|   | |     | + pure (\x_0 -> \x_1 -> x_0)-|   | |     | ` pure 'a'-|   | |     ` satisfy-|   | ` rec <hidden>-|   ` pure (\x_0 -> x_0)-` <*>-  + pure GHC.Show.show-  ` <*>-    + <*>-    | + pure (\x_0 -> \x_1 -> x_0)-    | ` <*>-    |   + ref <hidden>-    |   ` pure GHC.Types.[]-    ` <*>-      + <*>-      | + pure (\x_0 -> \x_1 -> x_0)-      | ` pure 'b'-      ` satisfy
− test/Golden/Grammar/ViewGrammar/G12.expected.txt 
@@ -1,20 +0,0 @@-lets-+ let <hidden>-| ` <|>-|   + <*>-|   | + <*>-|   | | + pure (\x_0 -> \x_1 -> \x_2 -> x_0 (x_1 x_2))-|   | | ` <*>-|   | |   + pure (GHC.Types.:)-|   | |   ` satisfy-|   | ` rec <hidden>-|   ` pure (\x_0 -> x_0)-` <*>-  + pure GHC.Show.show-  ` <*>-    + <*>-    | + pure (\x_0 -> \x_1 -> x_0)-    | ` <*>-    |   + ref <hidden>-    |   ` pure GHC.Types.[]-    ` eof
− test/Golden/Grammar/ViewGrammar/G13.expected.txt 
@@ -1,107 +0,0 @@-lets-+ let <hidden>-| ` <*>-|   + <*>-|   | + <*>-|   | | + pure (\x_0 -> \x_1 -> x_0)-|   | | ` pure (\x_0 -> x_0)-|   | ` <*>-|   |   + <*>-|   |   | + pure ((\x_0 -> \x_1 -> \x_2 -> x_0 x_2 x_1) (\x_3 -> \x_4 -> x_3 x_4))-|   |   | ` pure GHC.Tuple.()-|   |   ` ref <hidden>-|   ` pure GHC.Tuple.()-+ let <hidden>-| ` <*>-|   + ref <hidden>-|   ` pure GHC.Types.[]-+ let <hidden>-| ` <|>-|   + <*>-|   | + <*>-|   | | + pure (\x_0 -> \x_1 -> \x_2 -> x_0 (x_1 x_2))-|   | | ` <*>-|   | |   + <*>-|   | |   | + pure (\x_0 -> \x_1 -> \x_2 -> x_0 x_2 x_1)-|   | |   | ` pure (\x_0 -> \x_1 -> x_0)-|   | |   ` satisfy-|   | ` rec <hidden>-|   ` pure (\x_0 -> x_0)-+ let <hidden>-| ` <|>-|   + <*>-|   | + <*>-|   | | + pure (\x_0 -> \x_1 -> \x_2 -> x_0 (x_1 x_2))-|   | | ` <*>-|   | |   + pure (GHC.Types.:)-|   | |   ` <*>-|   | |     + <*>-|   | |     | + pure (\x_0 -> \x_1 -> x_0)-|   | |     | ` conditional-|   | |     |   + look-|   | |     |   | ` satisfy-|   | |     |   + branches-|   | |     |   | + <*>-|   | |     |   | | + <*>-|   | |     |   | | | + pure (\x_0 -> \x_1 -> x_0)-|   | |     |   | | | ` pure Parsers.Brainfuck.Types.Backward-|   | |     |   | | ` satisfy-|   | |     |   | + <*>-|   | |     |   | | + <*>-|   | |     |   | | | + pure (\x_0 -> \x_1 -> x_0)-|   | |     |   | | | ` pure Parsers.Brainfuck.Types.Forward-|   | |     |   | | ` satisfy-|   | |     |   | + <*>-|   | |     |   | | + <*>-|   | |     |   | | | + pure (\x_0 -> \x_1 -> x_0)-|   | |     |   | | | ` pure Parsers.Brainfuck.Types.Increment-|   | |     |   | | ` satisfy-|   | |     |   | + <*>-|   | |     |   | | + <*>-|   | |     |   | | | + pure (\x_0 -> \x_1 -> x_0)-|   | |     |   | | | ` pure Parsers.Brainfuck.Types.Decrement-|   | |     |   | | ` satisfy-|   | |     |   | + <*>-|   | |     |   | | + <*>-|   | |     |   | | | + pure (\x_0 -> \x_1 -> x_0)-|   | |     |   | | | ` pure Parsers.Brainfuck.Types.Input-|   | |     |   | | ` satisfy-|   | |     |   | + <*>-|   | |     |   | | + <*>-|   | |     |   | | | + pure (\x_0 -> \x_1 -> x_0)-|   | |     |   | | | ` pure Parsers.Brainfuck.Types.Output-|   | |     |   | | ` satisfy-|   | |     |   | ` <*>-|   | |     |   |   + <*>-|   | |     |   |   | + pure (\x_0 -> \x_1 -> x_0)-|   | |     |   |   | ` <*>-|   | |     |   |   |   + <*>-|   | |     |   |   |   | + <*>-|   | |     |   |   |   | | + pure (\x_0 -> \x_1 -> x_0)-|   | |     |   |   |   | | ` pure (\x_0 -> x_0)-|   | |     |   |   |   | ` <*>-|   | |     |   |   |   |   + <*>-|   | |     |   |   |   |   | + pure (\x_0 -> \x_1 -> x_0)-|   | |     |   |   |   |   | ` satisfy-|   | |     |   |   |   |   ` ref <hidden>-|   | |     |   |   |   ` <*>-|   | |     |   |   |     + pure Parsers.Brainfuck.Types.Loop-|   | |     |   |   |     ` rec <hidden>-|   | |     |   |   ` <*>-|   | |     |   |     + <*>-|   | |     |   |     | + pure (\x_0 -> \x_1 -> x_0)-|   | |     |   |     | ` pure ']'-|   | |     |   |     ` satisfy-|   | |     |   ` failure-|   | |     ` ref <hidden>-|   | ` rec <hidden>-|   ` pure (\x_0 -> x_0)-` <*>-  + pure GHC.Show.show-  ` <*>-    + <*>-    | + <*>-    | | + pure (\x_0 -> \x_1 -> x_0)-    | | ` pure (\x_0 -> x_0)-    | ` ref <hidden>-    ` ref <hidden>
− test/Golden/Grammar/ViewGrammar/G14.expected.txt 
@@ -1,844 +0,0 @@-lets-+ let <hidden>-| ` <*>-|   + <*>-|   | + <*>-|   | | + pure (\x_0 -> \x_1 -> x_0)-|   | | ` pure (\x_0 -> x_0)-|   | ` ref <hidden>-|   ` <*>-|     + <*>-|     | + <*>-|     | | + pure (\x_0 -> \x_1 -> x_0)-|     | | ` pure (\x_0 -> x_0)-|     | ` <*>-|     |   + <*>-|     |   | + pure ((\x_0 -> \x_1 -> \x_2 -> x_0 x_2 x_1) (\x_3 -> \x_4 -> x_3 x_4))-|     |   | ` pure GHC.Tuple.()-|     |   ` ref <hidden>-|     ` pure GHC.Tuple.()-+ let <hidden>-| ` <*>-|   + <*>-|   | + <*>-|   | | + pure (\x_0 -> \x_1 -> x_0)-|   | | ` pure (\x_0 -> x_0)-|   | ` ref <hidden>-|   ` <*>-|     + <*>-|     | + <*>-|     | | + pure (\x_0 -> \x_1 -> x_0)-|     | | ` pure (\x_0 -> x_0)-|     | ` <*>-|     |   + <*>-|     |   | + pure ((\x_0 -> \x_1 -> \x_2 -> x_0 x_2 x_1) (\x_3 -> \x_4 -> x_3 x_4))-|     |   | ` ref <hidden>-|     |   ` ref <hidden>-|     ` ref <hidden>-+ let <hidden>-| ` <*>-|   + <*>-|   | + pure (\x_0 -> \x_1 -> x_0)-|   | ` <*>-|   |   + <*>-|   |   | + <*>-|   |   | | + pure (\x_0 -> \x_1 -> x_0)-|   |   | | ` pure (\x_0 -> x_0)-|   |   | ` <*>-|   |   |   + <*>-|   |   |   | + pure (\x_0 -> \x_1 -> x_0)-|   |   |   | ` <*>-|   |   |   |   + <*>-|   |   |   |   | + pure (\x_0 -> \x_1 -> x_0)-|   |   |   |   | ` pure '['-|   |   |   |   ` satisfy-|   |   |   ` ref <hidden>-|   |   ` <*>-|   |     + <*>-|   |     | + <*>-|   |     | | + pure (\x_0 -> \x_1 -> x_0)-|   |     | | ` pure (\x_0 -> x_0)-|   |     | ` ref <hidden>-|   |     ` <*>-|   |       + <*>-|   |       | + <*>-|   |       | | + pure (\x_0 -> \x_1 -> x_0)-|   |       | | ` pure (\x_0 -> x_0)-|   |       | ` <*>-|   |       |   + <*>-|   |       |   | + pure ((\x_0 -> \x_1 -> \x_2 -> x_0 x_2 x_1) (\x_3 -> \x_4 -> x_3 x_4))-|   |       |   | ` pure GHC.Tuple.()-|   |       |   ` ref <hidden>-|   |       ` pure GHC.Tuple.()-|   ` <*>-|     + <*>-|     | + pure (\x_0 -> \x_1 -> x_0)-|     | ` <*>-|     |   + <*>-|     |   | + pure (\x_0 -> \x_1 -> x_0)-|     |   | ` pure ']'-|     |   ` satisfy-|     ` ref <hidden>-+ let <hidden>-| ` <*>-|   + <*>-|   | + pure (\x_0 -> \x_1 -> x_0)-|   | ` <*>-|   |   + <*>-|   |   | + <*>-|   |   | | + pure (\x_0 -> \x_1 -> x_0)-|   |   | | ` pure (\x_0 -> x_0)-|   |   | ` <*>-|   |   |   + <*>-|   |   |   | + pure (\x_0 -> \x_1 -> x_0)-|   |   |   | ` <*>-|   |   |   |   + <*>-|   |   |   |   | + pure (\x_0 -> \x_1 -> x_0)-|   |   |   |   | ` pure '{'-|   |   |   |   ` satisfy-|   |   |   ` ref <hidden>-|   |   ` <*>-|   |     + <*>-|   |     | + <*>-|   |     | | + pure (\x_0 -> \x_1 -> x_0)-|   |     | | ` pure (\x_0 -> x_0)-|   |     | ` <*>-|   |     |   + <*>-|   |     |   | + pure ((\x_0 -> \x_1 -> \x_2 -> x_0 x_2 x_1) (\x_3 -> \x_4 -> x_3 x_4))-|   |     |   | ` ref <hidden>-|   |     |   ` ref <hidden>-|   |     ` ref <hidden>-|   ` <*>-|     + <*>-|     | + pure (\x_0 -> \x_1 -> x_0)-|     | ` <*>-|     |   + <*>-|     |   | + pure (\x_0 -> \x_1 -> x_0)-|     |   | ` pure '}'-|     |   ` satisfy-|     ` ref <hidden>-+ let <hidden>-| ` <*>-|   + <*>-|   | + <*>-|   | | + pure (\x_0 -> \x_1 -> x_0)-|   | | ` pure (\x_0 -> x_0)-|   | ` ref <hidden>-|   ` <|>-|     + <*>-|     | + <*>-|     | | + pure (\x_0 -> \x_1 -> x_0)-|     | | ` pure GHC.Tuple.()-|     | ` ref <hidden>-|     ` ref <hidden>-+ let <hidden>-| ` <*>-|   + <*>-|   | + <*>-|   | | + pure (\x_0 -> \x_1 -> x_0)-|   | | ` pure (\x_0 -> x_0)-|   | ` satisfy-|   ` ref <hidden>-+ let <hidden>-| ` <*>-|   + <*>-|   | + <*>-|   | | + pure (\x_0 -> \x_1 -> x_0)-|   | | ` pure (\x_0 -> x_0)-|   | ` try-|   |   ` <*>-|   |     + <*>-|   |     | + <*>-|   |     | | + pure (\x_0 -> \x_1 -> x_0)-|   |     | | ` pure (\x_0 -> x_0)-|   |     | ` satisfy-|   |     ` <*>-|   |       + <*>-|   |       | + <*>-|   |       | | + pure (\x_0 -> \x_1 -> x_0)-|   |       | | ` pure (\x_0 -> x_0)-|   |       | ` <*>-|   |       |   + <*>-|   |       |   | + pure ((\x_0 -> \x_1 -> \x_2 -> x_0 x_2 x_1) (\x_3 -> \x_4 -> x_3 x_4))-|   |       |   | ` ref <hidden>-|   |       |   ` ref <hidden>-|   |       ` ref <hidden>-|   ` ref <hidden>-+ let <hidden>-| ` <*>-|   + <*>-|   | + pure (\x_0 -> \x_1 -> x_0)-|   | ` <*>-|   |   + <*>-|   |   | + pure (\x_0 -> \x_1 -> x_0)-|   |   | ` pure '('-|   |   ` satisfy-|   ` ref <hidden>-+ let <hidden>-| ` <*>-|   + <*>-|   | + pure (\x_0 -> \x_1 -> x_0)-|   | ` <*>-|   |   + <*>-|   |   | + pure (\x_0 -> \x_1 -> x_0)-|   |   | ` pure ')'-|   |   ` satisfy-|   ` ref <hidden>-+ let <hidden>-| ` <*>-|   + <*>-|   | + pure (\x_0 -> \x_1 -> x_0)-|   | ` <*>-|   |   + <*>-|   |   | + pure (\x_0 -> \x_1 -> x_0)-|   |   | ` pure ','-|   |   ` satisfy-|   ` ref <hidden>-+ let <hidden>-| ` <*>-|   + <*>-|   | + pure (\x_0 -> \x_1 -> x_0)-|   | ` <*>-|   |   + <*>-|   |   | + pure (\x_0 -> \x_1 -> x_0)-|   |   | ` pure ';'-|   |   ` satisfy-|   ` ref <hidden>-+ let <hidden>-| ` <*>-|   + pure (\x_0 -> \x_1 -> \x_2 -> x_0 x_2 x_1)-|   ` pure (\x_0 -> \x_1 -> x_0)-+ let <hidden>-| ` <|>-|   + <*>-|   | + <*>-|   | | + pure (\x_0 -> \x_1 -> \x_2 -> x_0 (x_1 x_2))-|   | | ` <*>-|   | |   + <*>-|   | |   | + pure (\x_0 -> \x_1 -> \x_2 -> x_0 x_2 x_1)-|   | |   | ` pure (\x_0 -> \x_1 -> x_0)-|   | |   ` <*>-|   | |     + <*>-|   | |     | + <*>-|   | |     | | + pure (\x_0 -> \x_1 -> x_0)-|   | |     | | ` pure (\x_0 -> x_0)-|   | |     | ` <*>-|   | |     |   + <*>-|   | |     |   | + <*>-|   | |     |   | | + pure (\x_0 -> \x_1 -> x_0)-|   | |     |   | | ` pure (\x_0 -> x_0)-|   | |     |   | ` <*>-|   | |     |   |   + <*>-|   | |     |   |   | + <*>-|   | |     |   |   | | + pure (\x_0 -> \x_1 -> x_0)-|   | |     |   |   | | ` pure (\x_0 -> x_0)-|   | |     |   |   | ` <*>-|   | |     |   |   |   + <*>-|   | |     |   |   |   | + <*>-|   | |     |   |   |   | | + pure (\x_0 -> \x_1 -> x_0)-|   | |     |   |   |   | | ` pure (\x_0 -> x_0)-|   | |     |   |   |   | ` try-|   | |     |   |   |   |   ` <*>-|   | |     |   |   |   |     + <*>-|   | |     |   |   |   |     | + pure (GHC.Types.:)-|   | |     |   |   |   |     | ` <*>-|   | |     |   |   |   |     |   + <*>-|   | |     |   |   |   |     |   | + pure (\x_0 -> \x_1 -> x_0)-|   | |     |   |   |   |     |   | ` pure 'f'-|   | |     |   |   |   |     |   ` satisfy-|   | |     |   |   |   |     ` <*>-|   | |     |   |   |   |       + <*>-|   | |     |   |   |   |       | + pure (GHC.Types.:)-|   | |     |   |   |   |       | ` <*>-|   | |     |   |   |   |       |   + <*>-|   | |     |   |   |   |       |   | + pure (\x_0 -> \x_1 -> x_0)-|   | |     |   |   |   |       |   | ` pure 'u'-|   | |     |   |   |   |       |   ` satisfy-|   | |     |   |   |   |       ` <*>-|   | |     |   |   |   |         + <*>-|   | |     |   |   |   |         | + pure (GHC.Types.:)-|   | |     |   |   |   |         | ` <*>-|   | |     |   |   |   |         |   + <*>-|   | |     |   |   |   |         |   | + pure (\x_0 -> \x_1 -> x_0)-|   | |     |   |   |   |         |   | ` pure 'n'-|   | |     |   |   |   |         |   ` satisfy-|   | |     |   |   |   |         ` <*>-|   | |     |   |   |   |           + <*>-|   | |     |   |   |   |           | + pure (GHC.Types.:)-|   | |     |   |   |   |           | ` <*>-|   | |     |   |   |   |           |   + <*>-|   | |     |   |   |   |           |   | + pure (\x_0 -> \x_1 -> x_0)-|   | |     |   |   |   |           |   | ` pure 'c'-|   | |     |   |   |   |           |   ` satisfy-|   | |     |   |   |   |           ` <*>-|   | |     |   |   |   |             + <*>-|   | |     |   |   |   |             | + pure (GHC.Types.:)-|   | |     |   |   |   |             | ` <*>-|   | |     |   |   |   |             |   + <*>-|   | |     |   |   |   |             |   | + pure (\x_0 -> \x_1 -> x_0)-|   | |     |   |   |   |             |   | ` pure 't'-|   | |     |   |   |   |             |   ` satisfy-|   | |     |   |   |   |             ` <*>-|   | |     |   |   |   |               + <*>-|   | |     |   |   |   |               | + pure (GHC.Types.:)-|   | |     |   |   |   |               | ` <*>-|   | |     |   |   |   |               |   + <*>-|   | |     |   |   |   |               |   | + pure (\x_0 -> \x_1 -> x_0)-|   | |     |   |   |   |               |   | ` pure 'i'-|   | |     |   |   |   |               |   ` satisfy-|   | |     |   |   |   |               ` <*>-|   | |     |   |   |   |                 + <*>-|   | |     |   |   |   |                 | + pure (GHC.Types.:)-|   | |     |   |   |   |                 | ` <*>-|   | |     |   |   |   |                 |   + <*>-|   | |     |   |   |   |                 |   | + pure (\x_0 -> \x_1 -> x_0)-|   | |     |   |   |   |                 |   | ` pure 'o'-|   | |     |   |   |   |                 |   ` satisfy-|   | |     |   |   |   |                 ` <*>-|   | |     |   |   |   |                   + <*>-|   | |     |   |   |   |                   | + pure (GHC.Types.:)-|   | |     |   |   |   |                   | ` <*>-|   | |     |   |   |   |                   |   + <*>-|   | |     |   |   |   |                   |   | + pure (\x_0 -> \x_1 -> x_0)-|   | |     |   |   |   |                   |   | ` pure 'n'-|   | |     |   |   |   |                   |   ` satisfy-|   | |     |   |   |   |                   ` pure GHC.Types.[]-|   | |     |   |   |   ` ref <hidden>-|   | |     |   |   ` ref <hidden>-|   | |     |   ` <*>-|   | |     |     + <*>-|   | |     |     | + pure (\x_0 -> \x_1 -> x_0)-|   | |     |     | ` <*>-|   | |     |     |   + <*>-|   | |     |     |   | + <*>-|   | |     |     |   | | + pure (\x_0 -> \x_1 -> x_0)-|   | |     |     |   | | ` pure (\x_0 -> x_0)-|   | |     |     |   | ` ref <hidden>-|   | |     |     |   ` <*>-|   | |     |     |     + <*>-|   | |     |     |     | + <*>-|   | |     |     |     | | + pure (\x_0 -> \x_1 -> x_0)-|   | |     |     |     | | ` pure (\x_0 -> x_0)-|   | |     |     |     | ` ref <hidden>-|   | |     |     |     ` <|>-|   | |     |     |       + <*>-|   | |     |     |       | + <*>-|   | |     |     |       | | + pure (\x_0 -> \x_1 -> x_0)-|   | |     |     |       | | ` pure GHC.Tuple.()-|   | |     |     |       | ` <*>-|   | |     |     |       |   + <*>-|   | |     |     |       |   | + <*>-|   | |     |     |       |   | | + pure (\x_0 -> \x_1 -> x_0)-|   | |     |     |       |   | | ` pure (\x_0 -> x_0)-|   | |     |     |       |   | ` <*>-|   | |     |     |       |   |   + <*>-|   | |     |     |       |   |   | + pure (\x_0 -> \x_1 -> x_0)-|   | |     |     |       |   |   | ` <*>-|   | |     |     |       |   |   |   + <*>-|   | |     |     |       |   |   |   | + pure (\x_0 -> \x_1 -> x_0)-|   | |     |     |       |   |   |   | ` pure ':'-|   | |     |     |       |   |   |   ` satisfy-|   | |     |     |       |   |   ` ref <hidden>-|   | |     |     |       |   ` ref <hidden>-|   | |     |     |       ` ref <hidden>-|   | |     |     ` ref <hidden>-|   | |     ` ref <hidden>-|   | ` rec <hidden>-|   ` pure (\x_0 -> x_0)-+ let <hidden>-| ` <|>-|   + <*>-|   | + <*>-|   | | + pure (\x_0 -> \x_1 -> \x_2 -> x_0 (x_1 x_2))-|   | | ` <*>-|   | |   + <*>-|   | |   | + pure (\x_0 -> \x_1 -> \x_2 -> x_0 x_2 x_1)-|   | |   | ` pure (\x_0 -> \x_1 -> x_0)-|   | |   ` <*>-|   | |     + <*>-|   | |     | + <*>-|   | |     | | + pure (\x_0 -> \x_1 -> x_0)-|   | |     | | ` pure (\x_0 -> x_0)-|   | |     | ` <*>-|   | |     |   + <*>-|   | |     |   | + pure (\x_0 -> \x_1 -> x_0)-|   | |     |   | ` <*>-|   | |     |   |   + <*>-|   | |     |   |   | + pure (\x_0 -> \x_1 -> x_0)-|   | |     |   |   | ` pure '!'-|   | |     |   |   ` satisfy-|   | |     |   ` ref <hidden>-|   | |     ` ref <hidden>-|   | ` rec <hidden>-|   ` pure (\x_0 -> x_0)-+ let <hidden>-| ` <|>-|   + <*>-|   | + <*>-|   | | + pure (\x_0 -> \x_1 -> \x_2 -> x_0 (x_1 x_2))-|   | | ` <*>-|   | |   + <*>-|   | |   | + pure (\x_0 -> \x_1 -> \x_2 -> x_0 x_2 x_1)-|   | |   | ` pure (\x_0 -> \x_1 -> x_0)-|   | |   ` <|>-|   | |     + <|>-|   | |     | + <|>-|   | |     | | + <*>-|   | |     | | | + <*>-|   | |     | | | | + <*>-|   | |     | | | | | + pure (\x_0 -> \x_1 -> x_0)-|   | |     | | | | | ` pure (\x_0 -> x_0)-|   | |     | | | | ` try-|   | |     | | | |   ` <*>-|   | |     | | | |     + <*>-|   | |     | | | |     | + pure (GHC.Types.:)-|   | |     | | | |     | ` <*>-|   | |     | | | |     |   + <*>-|   | |     | | | |     |   | + pure (\x_0 -> \x_1 -> x_0)-|   | |     | | | |     |   | ` pure 'i'-|   | |     | | | |     |   ` satisfy-|   | |     | | | |     ` <*>-|   | |     | | | |       + <*>-|   | |     | | | |       | + pure (GHC.Types.:)-|   | |     | | | |       | ` <*>-|   | |     | | | |       |   + <*>-|   | |     | | | |       |   | + pure (\x_0 -> \x_1 -> x_0)-|   | |     | | | |       |   | ` pure 'f'-|   | |     | | | |       |   ` satisfy-|   | |     | | | |       ` pure GHC.Types.[]-|   | |     | | | ` ref <hidden>-|   | |     | | ` <*>-|   | |     | |   + <*>-|   | |     | |   | + <*>-|   | |     | |   | | + pure (\x_0 -> \x_1 -> x_0)-|   | |     | |   | | ` pure (\x_0 -> x_0)-|   | |     | |   | ` <*>-|   | |     | |   |   + <*>-|   | |     | |   |   | + <*>-|   | |     | |   |   | | + pure (\x_0 -> \x_1 -> x_0)-|   | |     | |   |   | | ` pure (\x_0 -> x_0)-|   | |     | |   |   | ` <*>-|   | |     | |   |   |   + <*>-|   | |     | |   |   |   | + <*>-|   | |     | |   |   |   | | + pure (\x_0 -> \x_1 -> x_0)-|   | |     | |   |   |   | | ` pure (\x_0 -> x_0)-|   | |     | |   |   |   | ` try-|   | |     | |   |   |   |   ` <*>-|   | |     | |   |   |   |     + <*>-|   | |     | |   |   |   |     | + pure (GHC.Types.:)-|   | |     | |   |   |   |     | ` <*>-|   | |     | |   |   |   |     |   + <*>-|   | |     | |   |   |   |     |   | + pure (\x_0 -> \x_1 -> x_0)-|   | |     | |   |   |   |     |   | ` pure 'w'-|   | |     | |   |   |   |     |   ` satisfy-|   | |     | |   |   |   |     ` <*>-|   | |     | |   |   |   |       + <*>-|   | |     | |   |   |   |       | + pure (GHC.Types.:)-|   | |     | |   |   |   |       | ` <*>-|   | |     | |   |   |   |       |   + <*>-|   | |     | |   |   |   |       |   | + pure (\x_0 -> \x_1 -> x_0)-|   | |     | |   |   |   |       |   | ` pure 'h'-|   | |     | |   |   |   |       |   ` satisfy-|   | |     | |   |   |   |       ` <*>-|   | |     | |   |   |   |         + <*>-|   | |     | |   |   |   |         | + pure (GHC.Types.:)-|   | |     | |   |   |   |         | ` <*>-|   | |     | |   |   |   |         |   + <*>-|   | |     | |   |   |   |         |   | + pure (\x_0 -> \x_1 -> x_0)-|   | |     | |   |   |   |         |   | ` pure 'i'-|   | |     | |   |   |   |         |   ` satisfy-|   | |     | |   |   |   |         ` <*>-|   | |     | |   |   |   |           + <*>-|   | |     | |   |   |   |           | + pure (GHC.Types.:)-|   | |     | |   |   |   |           | ` <*>-|   | |     | |   |   |   |           |   + <*>-|   | |     | |   |   |   |           |   | + pure (\x_0 -> \x_1 -> x_0)-|   | |     | |   |   |   |           |   | ` pure 'l'-|   | |     | |   |   |   |           |   ` satisfy-|   | |     | |   |   |   |           ` <*>-|   | |     | |   |   |   |             + <*>-|   | |     | |   |   |   |             | + pure (GHC.Types.:)-|   | |     | |   |   |   |             | ` <*>-|   | |     | |   |   |   |             |   + <*>-|   | |     | |   |   |   |             |   | + pure (\x_0 -> \x_1 -> x_0)-|   | |     | |   |   |   |             |   | ` pure 'e'-|   | |     | |   |   |   |             |   ` satisfy-|   | |     | |   |   |   |             ` pure GHC.Types.[]-|   | |     | |   |   |   ` ref <hidden>-|   | |     | |   |   ` ref <hidden>-|   | |     | |   ` rec <hidden>-|   | |     | ` try-|   | |     |   ` <*>-|   | |     |     + <*>-|   | |     |     | + pure (\x_0 -> \x_1 -> x_0)-|   | |     |     | ` <*>-|   | |     |     |   + <*>-|   | |     |     |   | + <*>-|   | |     |     |   | | + pure (\x_0 -> \x_1 -> x_0)-|   | |     |     |   | | ` pure (\x_0 -> x_0)-|   | |     |     |   | ` <*>-|   | |     |     |   |   + <*>-|   | |     |     |   |   | + <*>-|   | |     |     |   |   | | + pure (\x_0 -> \x_1 -> x_0)-|   | |     |     |   |   | | ` pure (\x_0 -> x_0)-|   | |     |     |   |   | ` <*>-|   | |     |     |   |   |   + <*>-|   | |     |     |   |   |   | + <*>-|   | |     |     |   |   |   | | + pure (\x_0 -> \x_1 -> x_0)-|   | |     |     |   |   |   | | ` pure (\x_0 -> x_0)-|   | |     |     |   |   |   | ` <|>-|   | |     |     |   |   |   |   + <*>-|   | |     |     |   |   |   |   | + <*>-|   | |     |     |   |   |   |   | | + pure (\x_0 -> \x_1 -> x_0)-|   | |     |     |   |   |   |   | | ` pure GHC.Tuple.()-|   | |     |     |   |   |   |   | ` <*>-|   | |     |     |   |   |   |   |   + <*>-|   | |     |     |   |   |   |   |   | + <*>-|   | |     |     |   |   |   |   |   | | + pure (\x_0 -> \x_1 -> x_0)-|   | |     |     |   |   |   |   |   | | ` pure (\x_0 -> x_0)-|   | |     |     |   |   |   |   |   | ` try-|   | |     |     |   |   |   |   |   |   ` <*>-|   | |     |     |   |   |   |   |   |     + <*>-|   | |     |     |   |   |   |   |   |     | + pure (GHC.Types.:)-|   | |     |     |   |   |   |   |   |     | ` <*>-|   | |     |     |   |   |   |   |   |     |   + <*>-|   | |     |     |   |   |   |   |   |     |   | + pure (\x_0 -> \x_1 -> x_0)-|   | |     |     |   |   |   |   |   |     |   | ` pure 'v'-|   | |     |     |   |   |   |   |   |     |   ` satisfy-|   | |     |     |   |   |   |   |   |     ` <*>-|   | |     |     |   |   |   |   |   |       + <*>-|   | |     |     |   |   |   |   |   |       | + pure (GHC.Types.:)-|   | |     |     |   |   |   |   |   |       | ` <*>-|   | |     |     |   |   |   |   |   |       |   + <*>-|   | |     |     |   |   |   |   |   |       |   | + pure (\x_0 -> \x_1 -> x_0)-|   | |     |     |   |   |   |   |   |       |   | ` pure 'a'-|   | |     |     |   |   |   |   |   |       |   ` satisfy-|   | |     |     |   |   |   |   |   |       ` <*>-|   | |     |     |   |   |   |   |   |         + <*>-|   | |     |     |   |   |   |   |   |         | + pure (GHC.Types.:)-|   | |     |     |   |   |   |   |   |         | ` <*>-|   | |     |     |   |   |   |   |   |         |   + <*>-|   | |     |     |   |   |   |   |   |         |   | + pure (\x_0 -> \x_1 -> x_0)-|   | |     |     |   |   |   |   |   |         |   | ` pure 'r'-|   | |     |     |   |   |   |   |   |         |   ` satisfy-|   | |     |     |   |   |   |   |   |         ` pure GHC.Types.[]-|   | |     |     |   |   |   |   |   ` ref <hidden>-|   | |     |     |   |   |   |   ` ref <hidden>-|   | |     |     |   |   |   ` <*>-|   | |     |     |   |   |     + <*>-|   | |     |     |   |   |     | + <*>-|   | |     |     |   |   |     | | + pure (\x_0 -> \x_1 -> x_0)-|   | |     |     |   |   |     | | ` pure (\x_0 -> x_0)-|   | |     |     |   |   |     | ` ref <hidden>-|   | |     |     |   |   |     ` <*>-|   | |     |     |   |   |       + <*>-|   | |     |     |   |   |       | + <*>-|   | |     |     |   |   |       | | + pure (\x_0 -> \x_1 -> x_0)-|   | |     |     |   |   |       | | ` pure (\x_0 -> x_0)-|   | |     |     |   |   |       | ` <*>-|   | |     |     |   |   |       |   + <*>-|   | |     |     |   |   |       |   | + pure ((\x_0 -> \x_1 -> \x_2 -> x_0 x_2 x_1) (\x_3 -> \x_4 -> x_3 x_4))-|   | |     |     |   |   |       |   | ` ref <hidden>-|   | |     |     |   |   |       |   ` ref <hidden>-|   | |     |     |   |   |       ` ref <hidden>-|   | |     |     |   |   ` <*>-|   | |     |     |   |     + <*>-|   | |     |     |   |     | + pure (\x_0 -> \x_1 -> x_0)-|   | |     |     |   |     | ` <*>-|   | |     |     |   |     |   + <*>-|   | |     |     |   |     |   | + pure (\x_0 -> \x_1 -> x_0)-|   | |     |     |   |     |   | ` pure '='-|   | |     |     |   |     |   ` satisfy-|   | |     |     |   |     ` ref <hidden>-|   | |     |     |   ` <*>-|   | |     |     |     + <*>-|   | |     |     |     | + <*>-|   | |     |     |     | | + pure (\x_0 -> \x_1 -> x_0)-|   | |     |     |     | | ` pure (\x_0 -> x_0)-|   | |     |     |     | ` ref <hidden>-|   | |     |     |     ` <*>-|   | |     |     |       + <*>-|   | |     |     |       | + <*>-|   | |     |     |       | | + pure (\x_0 -> \x_1 -> x_0)-|   | |     |     |       | | ` pure (\x_0 -> x_0)-|   | |     |     |       | ` <*>-|   | |     |     |       |   + <*>-|   | |     |     |       |   | + pure ((\x_0 -> \x_1 -> \x_2 -> x_0 x_2 x_1) (\x_3 -> \x_4 -> x_3 x_4))-|   | |     |     |       |   | ` ref <hidden>-|   | |     |     |       |   ` ref <hidden>-|   | |     |     |       ` ref <hidden>-|   | |     |     ` ref <hidden>-|   | |     ` <*>-|   | |       + <*>-|   | |       | + pure (\x_0 -> \x_1 -> x_0)-|   | |       | ` ref <hidden>-|   | |       ` ref <hidden>-|   | ` rec <hidden>-|   ` pure (\x_0 -> x_0)-+ let <hidden>-| ` <|>-|   + <*>-|   | + <*>-|   | | + pure (\x_0 -> \x_1 -> \x_2 -> x_0 (x_1 x_2))-|   | | ` <*>-|   | |   + <*>-|   | |   | + pure (\x_0 -> \x_1 -> \x_2 -> x_0 x_2 x_1)-|   | |   | ` pure (\x_0 -> \x_1 -> x_0)-|   | |   ` ref <hidden>-|   | ` rec <hidden>-|   ` pure (\x_0 -> x_0)-+ let <hidden>-| ` <|>-|   + <*>-|   | + <*>-|   | | + pure (\x_0 -> \x_1 -> \x_2 -> x_0 (x_1 x_2))-|   | | ` <*>-|   | |   + <*>-|   | |   | + pure (\x_0 -> \x_1 -> \x_2 -> x_0 x_2 x_1)-|   | |   | ` pure (\x_0 -> \x_1 -> x_0)-|   | |   ` ref <hidden>-|   | ` rec <hidden>-|   ` pure (\x_0 -> x_0)-+ let <hidden>-| ` <|>-|   + <*>-|   | + <*>-|   | | + pure (\x_0 -> \x_1 -> \x_2 -> x_0 (x_1 x_2))-|   | | ` <*>-|   | |   + <*>-|   | |   | + pure (\x_0 -> \x_1 -> \x_2 -> x_0 x_2 x_1)-|   | |   | ` pure (\x_0 -> \x_1 -> x_0)-|   | |   ` satisfy-|   | ` rec <hidden>-|   ` pure (\x_0 -> x_0)-+ let <hidden>-| ` <|>-|   + <*>-|   | + <*>-|   | | + pure (\x_0 -> \x_1 -> \x_2 -> x_0 (x_1 x_2))-|   | | ` <*>-|   | |   + ref <hidden>-|   | |   ` <*>-|   | |     + <*>-|   | |     | + <*>-|   | |     | | + pure (\x_0 -> \x_1 -> x_0)-|   | |     | | ` pure (\x_0 -> x_0)-|   | |     | ` ref <hidden>-|   | |     ` rec <hidden>-|   | ` rec <hidden>-|   ` pure (\x_0 -> x_0)-+ let <hidden>-| ` <|>-|   + <*>-|   | + <*>-|   | | + pure (\x_0 -> \x_1 -> \x_2 -> x_0 (x_1 x_2))-|   | | ` <*>-|   | |   + ref <hidden>-|   | |   ` <*>-|   | |     + <*>-|   | |     | + <*>-|   | |     | | + pure (\x_0 -> \x_1 -> x_0)-|   | |     | | ` pure (\x_0 -> x_0)-|   | |     | ` ref <hidden>-|   | |     ` ref <hidden>-|   | ` rec <hidden>-|   ` pure (\x_0 -> x_0)-+ let <hidden>-| ` <|>-|   + <*>-|   | + <*>-|   | | + pure (\x_0 -> \x_1 -> \x_2 -> x_0 (x_1 x_2))-|   | | ` <*>-|   | |   + ref <hidden>-|   | |   ` <*>-|   | |     + <*>-|   | |     | + <*>-|   | |     | | + pure (\x_0 -> \x_1 -> x_0)-|   | |     | | ` pure (\x_0 -> x_0)-|   | |     | ` ref <hidden>-|   | |     ` ref <hidden>-|   | ` rec <hidden>-|   ` pure (\x_0 -> x_0)-+ let <hidden>-| ` <|>-|   + <*>-|   | + <*>-|   | | + pure (\x_0 -> \x_1 -> \x_2 -> x_0 (x_1 x_2))-|   | | ` <*>-|   | |   + ref <hidden>-|   | |   ` <*>-|   | |     + <*>-|   | |     | + <*>-|   | |     | | + pure (\x_0 -> \x_1 -> x_0)-|   | |     | | ` pure (\x_0 -> x_0)-|   | |     | ` ref <hidden>-|   | |     ` ref <hidden>-|   | ` rec <hidden>-|   ` pure (\x_0 -> x_0)-+ let <hidden>-| ` <|>-|   + <*>-|   | + <*>-|   | | + pure (\x_0 -> \x_1 -> x_0)-|   | | ` pure GHC.Tuple.()-|   | ` <*>-|   |   + <*>-|   |   | + <*>-|   |   | | + pure (\x_0 -> \x_1 -> x_0)-|   |   | | ` pure (\x_0 -> x_0)-|   |   | ` ref <hidden>-|   |   ` <*>-|   |     + <*>-|   |     | + <*>-|   |     | | + pure (\x_0 -> \x_1 -> x_0)-|   |     | | ` pure (\x_0 -> x_0)-|   |     | ` <*>-|   |     |   + <*>-|   |     |   | + pure ((\x_0 -> \x_1 -> \x_2 -> x_0 x_2 x_1) (\x_3 -> \x_4 -> x_3 x_4))-|   |     |   | ` ref <hidden>-|   |     |   ` ref <hidden>-|   |     ` ref <hidden>-|   ` ref <hidden>-+ let <hidden>-| ` <|>-|   + <|>-|   | + <*>-|   | | + <*>-|   | | | + <*>-|   | | | | + pure (\x_0 -> \x_1 -> x_0)-|   | | | | ` pure (\x_0 -> x_0)-|   | | | ` <|>-|   | | |   + <*>-|   | | |   | + <*>-|   | | |   | | + pure (\x_0 -> \x_1 -> x_0)-|   | | |   | | ` pure '0'-|   | | |   | ` satisfy-|   | | |   ` <*>-|   | | |     + <*>-|   | | |     | + pure (\x_0 -> \x_1 -> x_0)-|   | | |     | ` pure '1'-|   | | |     ` satisfy-|   | | ` ref <hidden>-|   | ` <*>-|   |   + <*>-|   |   | + pure (\x_0 -> \x_1 -> x_0)-|   |   | ` <*>-|   |   |   + <*>-|   |   |   | + <*>-|   |   |   | | + pure (\x_0 -> \x_1 -> x_0)-|   |   |   | | ` pure (\x_0 -> x_0)-|   |   |   | ` <*>-|   |   |   |   + <*>-|   |   |   |   | + pure (\x_0 -> \x_1 -> x_0)-|   |   |   |   | ` pure '\''-|   |   |   |   ` satisfy-|   |   |   ` <|>-|   |   |     + <*>-|   |   |     | + <*>-|   |   |     | | + <*>-|   |   |     | | | + pure (\x_0 -> \x_1 -> x_0)-|   |   |     | | | ` pure (\x_0 -> x_0)-|   |   |     | | ` satisfy-|   |   |     | ` ref <hidden>-|   |   |     ` <*>-|   |   |       + <*>-|   |   |       | + <*>-|   |   |       | | + pure (\x_0 -> \x_1 -> x_0)-|   |   |       | | ` pure (\x_0 -> x_0)-|   |   |       | ` <*>-|   |   |       |   + <*>-|   |   |       |   | + pure (\x_0 -> \x_1 -> x_0)-|   |   |       |   | ` pure '\\'-|   |   |       |   ` satisfy-|   |   |       ` <*>-|   |   |         + <*>-|   |   |         | + <*>-|   |   |         | | + pure (\x_0 -> \x_1 -> x_0)-|   |   |         | | ` pure (\x_0 -> x_0)-|   |   |         | ` satisfy-|   |   |         ` ref <hidden>-|   |   ` <*>-|   |     + <*>-|   |     | + pure (\x_0 -> \x_1 -> x_0)-|   |     | ` <*>-|   |     |   + <*>-|   |     |   | + pure (\x_0 -> \x_1 -> x_0)-|   |     |   | ` pure '\''-|   |     |   ` satisfy-|   |     ` ref <hidden>-|   ` <*>-|     + <*>-|     | + <*>-|     | | + pure (\x_0 -> \x_1 -> x_0)-|     | | ` pure (\x_0 -> x_0)-|     | ` ref <hidden>-|     ` <|>-|       + <*>-|       | + <*>-|       | | + pure (\x_0 -> \x_1 -> x_0)-|       | | ` pure GHC.Tuple.()-|       | ` <|>-|       |   + <*>-|       |   | + <*>-|       |   | | + pure (\x_0 -> \x_1 -> x_0)-|       |   | | ` <*>-|       |   | |   + <*>-|       |   | |   | + <*>-|       |   | |   | | + pure (\x_0 -> \x_1 -> x_0)-|       |   | |   | | ` pure (\x_0 -> x_0)-|       |   | |   | ` ref <hidden>-|       |   | |   ` <|>-|       |   | |     + <*>-|       |   | |     | + <*>-|       |   | |     | | + pure (\x_0 -> \x_1 -> x_0)-|       |   | |     | | ` pure GHC.Tuple.()-|       |   | |     | ` <*>-|       |   | |     |   + <*>-|       |   | |     |   | + <*>-|       |   | |     |   | | + pure (\x_0 -> \x_1 -> x_0)-|       |   | |     |   | | ` pure (\x_0 -> x_0)-|       |   | |     |   | ` rec <hidden>-|       |   | |     |   ` <*>-|       |   | |     |     + <*>-|       |   | |     |     | + <*>-|       |   | |     |     | | + pure (\x_0 -> \x_1 -> x_0)-|       |   | |     |     | | ` pure (\x_0 -> x_0)-|       |   | |     |     | ` <*>-|       |   | |     |     |   + <*>-|       |   | |     |     |   | + pure ((\x_0 -> \x_1 -> \x_2 -> x_0 x_2 x_1) (\x_3 -> \x_4 -> x_3 x_4))-|       |   | |     |     |   | ` ref <hidden>-|       |   | |     |     |   ` ref <hidden>-|       |   | |     |     ` ref <hidden>-|       |   | |     ` ref <hidden>-|       |   | ` ref <hidden>-|       |   ` ref <hidden>-|       ` ref <hidden>-+ let <hidden>-| ` pure GHC.Tuple.()-+ let <hidden>-| ` pure GHC.Tuple.()-+ let <hidden>-| ` satisfy-` <*>-  + pure GHC.Show.show-  ` <*>-    + <*>-    | + pure (\x_0 -> \x_1 -> x_0)-    | ` <*>-    |   + <*>-    |   | + <*>-    |   | | + pure (\x_0 -> \x_1 -> x_0)-    |   | | ` pure (\x_0 -> x_0)-    |   | ` ref <hidden>-    |   ` <*>-    |     + <*>-    |     | + <*>-    |     | | + pure (\x_0 -> \x_1 -> x_0)-    |     | | ` pure (\x_0 -> x_0)-    |     | ` <*>-    |     |   + <*>-    |     |   | + pure ((\x_0 -> \x_1 -> \x_2 -> x_0 x_2 x_1) (\x_3 -> \x_4 -> x_3 x_4))-    |     |   | ` ref <hidden>-    |     |   ` ref <hidden>-    |     ` ref <hidden>-    ` eof
− test/Golden/Grammar/ViewGrammar/G15.expected.txt 
@@ -1,22 +0,0 @@-lets-` <*>-  + pure GHC.Show.show-  ` <*>-    + <*>-    | + pure (\x_0 -> \x_1 -> x_0)-    | ` <|>-    |   + <*>-    |   | + <*>-    |   | | + pure (\x_0 -> \x_1 -> x_0)-    |   | | ` pure 'a'-    |   | ` satisfy-    |   ` <*>-    |     + <*>-    |     | + pure (\x_0 -> \x_1 -> x_0)-    |     | ` pure 'b'-    |     ` satisfy-    ` <*>-      + <*>-      | + pure (\x_0 -> \x_1 -> x_0)-      | ` pure 'c'-      ` satisfy
− test/Golden/Grammar/ViewGrammar/G16.expected.txt 
@@ -1,28 +0,0 @@-lets-` <*>-  + pure GHC.Show.show-  ` <*>-    + <*>-    | + pure (\x_0 -> \x_1 -> x_0)-    | ` <|>-    |   + <|>-    |   | + <*>-    |   | | + <*>-    |   | | | + pure (\x_0 -> \x_1 -> x_0)-    |   | | | ` pure 'a'-    |   | | ` satisfy-    |   | ` <*>-    |   |   + <*>-    |   |   | + pure (\x_0 -> \x_1 -> x_0)-    |   |   | ` pure 'b'-    |   |   ` satisfy-    |   ` <*>-    |     + <*>-    |     | + pure (\x_0 -> \x_1 -> x_0)-    |     | ` pure 'c'-    |     ` satisfy-    ` <*>-      + <*>-      | + pure (\x_0 -> \x_1 -> x_0)-      | ` pure 'd'-      ` satisfy
− test/Golden/Grammar/ViewGrammar/G2.expected.txt 
@@ -1,29 +0,0 @@-lets-` <*>-  + pure GHC.Show.show-  ` try-    ` <*>-      + <*>-      | + pure (GHC.Types.:)-      | ` <*>-      |   + <*>-      |   | + pure (\x_0 -> \x_1 -> x_0)-      |   | ` pure 'a'-      |   ` satisfy-      ` <*>-        + <*>-        | + pure (GHC.Types.:)-        | ` <*>-        |   + <*>-        |   | + pure (\x_0 -> \x_1 -> x_0)-        |   | ` pure 'b'-        |   ` satisfy-        ` <*>-          + <*>-          | + pure (GHC.Types.:)-          | ` <*>-          |   + <*>-          |   | + pure (\x_0 -> \x_1 -> x_0)-          |   | ` pure 'c'-          |   ` satisfy-          ` pure GHC.Types.[]
− test/Golden/Grammar/ViewGrammar/G3.expected.txt 
@@ -1,20 +0,0 @@-lets-+ let <hidden>-| ` <|>-|   + <*>-|   | + <*>-|   | | + pure (\x_0 -> \x_1 -> \x_2 -> x_0 (x_1 x_2))-|   | | ` <*>-|   | |   + pure (GHC.Types.:)-|   | |   ` <*>-|   | |     + <*>-|   | |     | + pure (\x_0 -> \x_1 -> x_0)-|   | |     | ` pure 'a'-|   | |     ` satisfy-|   | ` rec <hidden>-|   ` pure (\x_0 -> x_0)-` <*>-  + pure GHC.Show.show-  ` <*>-    + ref <hidden>-    ` pure GHC.Types.[]
− test/Golden/Grammar/ViewGrammar/G4.expected.txt 
@@ -1,55 +0,0 @@-lets-+ let <hidden>-| ` <|>-|   + <*>-|   | + <*>-|   | | + pure (\x_0 -> \x_1 -> \x_2 -> x_0 (x_1 x_2))-|   | | ` <*>-|   | |   + pure (GHC.Types.:)-|   | |   ` ref <hidden>-|   | ` rec <hidden>-|   ` pure (\x_0 -> x_0)-+ let <hidden>-| ` try-|   ` <*>-|     + <*>-|     | + pure (GHC.Types.:)-|     | ` <*>-|     |   + <*>-|     |   | + pure (\x_0 -> \x_1 -> x_0)-|     |   | ` pure 'a'-|     |   ` satisfy-|     ` <*>-|       + <*>-|       | + pure (GHC.Types.:)-|       | ` <*>-|       |   + <*>-|       |   | + pure (\x_0 -> \x_1 -> x_0)-|       |   | ` pure 'b'-|       |   ` satisfy-|       ` <*>-|         + <*>-|         | + pure (GHC.Types.:)-|         | ` <*>-|         |   + <*>-|         |   | + pure (\x_0 -> \x_1 -> x_0)-|         |   | ` pure 'c'-|         |   ` satisfy-|         ` <*>-|           + <*>-|           | + pure (GHC.Types.:)-|           | ` <*>-|           |   + <*>-|           |   | + pure (\x_0 -> \x_1 -> x_0)-|           |   | ` pure 'd'-|           |   ` satisfy-|           ` pure GHC.Types.[]-` <*>-  + pure GHC.Show.show-  ` <*>-    + <*>-    | + pure (GHC.Types.:)-    | ` ref <hidden>-    ` <*>-      + ref <hidden>-      ` pure GHC.Types.[]
− test/Golden/Grammar/ViewGrammar/G5.expected.txt 
@@ -1,59 +0,0 @@-lets-+ let <hidden>-| ` <|>-|   + <*>-|   | + <*>-|   | | + pure (\x_0 -> \x_1 -> \x_2 -> x_0 (x_1 x_2))-|   | | ` <*>-|   | |   + pure (GHC.Types.:)-|   | |   ` ref <hidden>-|   | ` rec <hidden>-|   ` pure (\x_0 -> x_0)-+ let <hidden>-| ` try-|   ` <*>-|     + <*>-|     | + pure (GHC.Types.:)-|     | ` <*>-|     |   + <*>-|     |   | + pure (\x_0 -> \x_1 -> x_0)-|     |   | ` pure 'a'-|     |   ` satisfy-|     ` <*>-|       + <*>-|       | + pure (GHC.Types.:)-|       | ` <*>-|       |   + <*>-|       |   | + pure (\x_0 -> \x_1 -> x_0)-|       |   | ` pure 'b'-|       |   ` satisfy-|       ` <*>-|         + <*>-|         | + pure (GHC.Types.:)-|         | ` <*>-|         |   + <*>-|         |   | + pure (\x_0 -> \x_1 -> x_0)-|         |   | ` pure 'c'-|         |   ` satisfy-|         ` <*>-|           + <*>-|           | + pure (GHC.Types.:)-|           | ` <*>-|           |   + <*>-|           |   | + pure (\x_0 -> \x_1 -> x_0)-|           |   | ` pure 'd'-|           |   ` satisfy-|           ` pure GHC.Types.[]-` <*>-  + pure GHC.Show.show-  ` <*>-    + <*>-    | + pure (\x_0 -> \x_1 -> x_0)-    | ` <*>-    |   + <*>-    |   | + pure (GHC.Types.:)-    |   | ` ref <hidden>-    |   ` <*>-    |     + ref <hidden>-    |     ` pure GHC.Types.[]-    ` eof
− test/Golden/Grammar/ViewGrammar/G6.expected.txt 
@@ -1,38 +0,0 @@-lets-` <*>-  + pure GHC.Show.show-  ` <|>-    + <*>-    | + <*>-    | | + pure (GHC.Types.:)-    | | ` <*>-    | |   + <*>-    | |   | + pure (\x_0 -> \x_1 -> x_0)-    | |   | ` pure 'a'-    | |   ` satisfy-    | ` <*>-    |   + <*>-    |   | + pure (GHC.Types.:)-    |   | ` <*>-    |   |   + <*>-    |   |   | + pure (\x_0 -> \x_1 -> x_0)-    |   |   | ` pure 'a'-    |   |   ` satisfy-    |   ` pure GHC.Types.[]-    ` <*>-      + <*>-      | + pure (GHC.Types.:)-      | ` <*>-      |   + <*>-      |   | + pure (\x_0 -> \x_1 -> x_0)-      |   | ` pure 'a'-      |   ` satisfy-      ` <*>-        + <*>-        | + pure (GHC.Types.:)-        | ` <*>-        |   + <*>-        |   | + pure (\x_0 -> \x_1 -> x_0)-        |   | ` pure 'b'-        |   ` satisfy-        ` pure GHC.Types.[]
− test/Golden/Grammar/ViewGrammar/G7.expected.txt 
@@ -1,40 +0,0 @@-lets-` <*>-  + pure GHC.Show.show-  ` <|>-    + try-    | ` <*>-    |   + <*>-    |   | + pure (GHC.Types.:)-    |   | ` <*>-    |   |   + <*>-    |   |   | + pure (\x_0 -> \x_1 -> x_0)-    |   |   | ` pure 'a'-    |   |   ` satisfy-    |   ` <*>-    |     + <*>-    |     | + pure (GHC.Types.:)-    |     | ` <*>-    |     |   + <*>-    |     |   | + pure (\x_0 -> \x_1 -> x_0)-    |     |   | ` pure 'a'-    |     |   ` satisfy-    |     ` pure GHC.Types.[]-    ` try-      ` <*>-        + <*>-        | + pure (GHC.Types.:)-        | ` <*>-        |   + <*>-        |   | + pure (\x_0 -> \x_1 -> x_0)-        |   | ` pure 'a'-        |   ` satisfy-        ` <*>-          + <*>-          | + pure (GHC.Types.:)-          | ` <*>-          |   + <*>-          |   | + pure (\x_0 -> \x_1 -> x_0)-          |   | ` pure 'b'-          |   ` satisfy-          ` pure GHC.Types.[]
− test/Golden/Grammar/ViewGrammar/G8.expected.txt 
@@ -1,24 +0,0 @@-lets-+ let <hidden>-| ` <|>-|   + <*>-|   | + <*>-|   | | + pure (\x_0 -> \x_1 -> \x_2 -> x_0 (x_1 x_2))-|   | | ` <*>-|   | |   + pure (GHC.Types.:)-|   | |   ` <*>-|   | |     + <*>-|   | |     | + pure (\x_0 -> \x_1 -> x_0)-|   | |     | ` pure 'r'-|   | |     ` satisfy-|   | ` rec <hidden>-|   ` pure (\x_0 -> x_0)-` <*>-  + pure GHC.Show.show-  ` <*>-    + <*>-    | + pure (\x_0 -> \x_1 -> x_0)-    | ` <*>-    |   + ref <hidden>-    |   ` pure GHC.Types.[]-    ` eof
− test/Golden/Grammar/ViewGrammar/G9.expected.txt 
@@ -1,4 +0,0 @@-lets-` <*>-  + pure GHC.Show.show-  ` eof
− test/Golden/Machine.hs 
@@ -1,41 +0,0 @@-{-# LANGUAGE DataKinds #-} -- For using P.viewMachine-{-# LANGUAGE FlexibleContexts #-} -- For machines-{-# LANGUAGE GADTs #-} -- For machines-{-# LANGUAGE TypeApplications #-} -- For P.viewMachine-module Golden.Machine where--import Data.Bool (Bool(..))-import Data.Char (Char)-import Control.Monad (Monad(..))-import Data.Int (Int)-import Data.Function (($))-import Data.Functor ((<$>))-import Data.Semigroup (Semigroup(..))-import Data.String (String, IsString(..))-import Data.Text (Text)-import System.IO (IO)-import Test.Tasty-import Test.Tasty.Golden-import Text.Show (Show(..))-import qualified Data.List as List--import Golden.Utils-import Grammar-import qualified Symantic.Parser as P--goldens :: TestTree-goldens = testGroup "Machine" $-  (\f -> List.zipWith f (machines @Text) [1::Int ..]) $ \mach g ->-  let machineFile = getGoldenDir $ "Machine/G"<>show g<>".expected.txt" in-  goldenVsStringDiff ("G"<>show g) goldenDiff machineFile $ do-    resetTHNameCounter-    m <- mach-    return $ fromString $ show $-      P.viewMachine @'False m--machines ::-  P.InputToken inp ~ Char =>-  P.Cursorable (P.Cursor inp) =>-  P.Machinable (P.InputToken inp) repr =>-  [IO (repr inp '[] String)]-machines = P.optimizeMachine <$> grammars
− test/Golden/Machine/G1.expected.txt 
@@ -1,24 +0,0 @@-pushValue GHC.Show.show-  minReads=(Right 1)-  mayRaise=[ExceptionFailure]-pushValue (\x_0 -> \x_1 -> x_0)-  minReads=(Right 1)-  mayRaise=[ExceptionFailure]-pushValue 'a'-  minReads=(Right 1)-  mayRaise=[ExceptionFailure]-lift2Value (\x_0 -> \x_1 -> x_0 x_1)-  minReads=(Right 1)-  mayRaise=[ExceptionFailure]-read ((GHC.Classes.==) 'a')-  minReads=(Right 1)-  mayRaise=[ExceptionFailure]-lift2Value (\x_0 -> \x_1 -> x_0 x_1)-  minReads=(Right 0)-  mayRaise=[]-lift2Value (\x_0 -> \x_1 -> x_0 x_1)-  minReads=(Right 0)-  mayRaise=[]-ret-  minReads=(Right 0)-  mayRaise=[]
− test/Golden/Machine/G10.expected.txt 
@@ -1,72 +0,0 @@-pushValue GHC.Show.show-  minReads=(Right 1)-  mayRaise=[ExceptionFailure]-join <hidden>-  minReads=(Right 0)-  mayRaise=[]-| lift2Value (\x_0 -> \x_1 -> x_0 x_1)-|   minReads=(Right 0)-|   mayRaise=[]-| ret-|   minReads=(Right 0)-|   mayRaise=[]-catch ExceptionFailure-  minReads=(Right 1)-  mayRaise=[ExceptionFailure]-| <ok>-| | pushValue (\x_0 -> \x_1 -> x_0)-| |   minReads=(Right 1)-| |   mayRaise=[ExceptionFailure]-| | pushValue 'a'-| |   minReads=(Right 1)-| |   mayRaise=[ExceptionFailure]-| | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| |   minReads=(Right 1)-| |   mayRaise=[ExceptionFailure]-| | read ((GHC.Classes.==) 'a')-| |   minReads=(Right 1)-| |   mayRaise=[ExceptionFailure]-| | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| |   minReads=(Right 0)-| |   mayRaise=[]-| | commit ExceptionFailure-| |   minReads=(Right 0)-| |   mayRaise=[]-| | refJoin <hidden>-| |   minReads=(Right 0)-| |   mayRaise=[]-| <ko>-| | pushInput-| |   minReads=(Right 1)-| |   mayRaise=[ExceptionFailure]-| | lift2Value (\(Data.Text.Internal.Text _ i_0 _) (Data.Text.Internal.Text _-| |                                                                j_1-| |                                                                _) -> i_0 GHC.Classes.== j_1)-| |   minReads=(Right 1)-| |   mayRaise=[ExceptionFailure]-| | choicesBranch [\x_0 -> x_0]-| |   minReads=(Right 1)-| |   mayRaise=[ExceptionFailure]-| | | <branch>-| | | | pushValue (\x_0 -> \x_1 -> x_0)-| | | |   minReads=(Right 1)-| | | |   mayRaise=[ExceptionFailure]-| | | | pushValue 'b'-| | | |   minReads=(Right 1)-| | | |   mayRaise=[ExceptionFailure]-| | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | |   minReads=(Right 1)-| | | |   mayRaise=[ExceptionFailure]-| | | | read ((GHC.Classes.==) 'b')-| | | |   minReads=(Right 1)-| | | |   mayRaise=[ExceptionFailure]-| | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | |   minReads=(Right 0)-| | | |   mayRaise=[]-| | | | refJoin <hidden>-| | | |   minReads=(Right 0)-| | | |   mayRaise=[]-| | | <default>-| | | | fail []-| | | |   minReads=(Left ExceptionFailure)-| | | |   mayRaise=[ExceptionFailure]
− test/Golden/Machine/G11.expected.txt 
@@ -1,111 +0,0 @@-let <hidden>-  minReads=(Right 0)-  mayRaise=[ExceptionFailure]-| catch ExceptionFailure-|   minReads=(Right 0)-|   mayRaise=[ExceptionFailure]-| | <ok>-| | | pushValue (\x_0 -> \x_1 -> \x_2 -> x_0 (x_1 x_2))-| | |   minReads=(Right 1)-| | |   mayRaise=[ExceptionFailure]-| | | pushValue (GHC.Types.:)-| | |   minReads=(Right 1)-| | |   mayRaise=[ExceptionFailure]-| | | pushValue (\x_0 -> \x_1 -> x_0)-| | |   minReads=(Right 1)-| | |   mayRaise=[ExceptionFailure]-| | | pushValue 'a'-| | |   minReads=(Right 1)-| | |   mayRaise=[ExceptionFailure]-| | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | |   minReads=(Right 1)-| | |   mayRaise=[ExceptionFailure]-| | | read ((GHC.Classes.==) 'a')-| | |   minReads=(Right 1)-| | |   mayRaise=[ExceptionFailure]-| | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | |   minReads=(Right 0)-| | |   mayRaise=[ExceptionFailure]-| | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | |   minReads=(Right 0)-| | |   mayRaise=[ExceptionFailure]-| | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | |   minReads=(Right 0)-| | |   mayRaise=[ExceptionFailure]-| | | call <hidden>-| | |   minReads=(Right 0)-| | |   mayRaise=[ExceptionFailure]-| | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | |   minReads=(Right 0)-| | |   mayRaise=[]-| | | commit ExceptionFailure-| | |   minReads=(Right 0)-| | |   mayRaise=[]-| | | ret-| | |   minReads=(Right 0)-| | |   mayRaise=[]-| | <ko>-| | | pushInput-| | |   minReads=(Right 0)-| | |   mayRaise=[ExceptionFailure]-| | | lift2Value (\(Data.Text.Internal.Text _ i_0 _) (Data.Text.Internal.Text _-| | |                                                                j_1-| | |                                                                _) -> i_0 GHC.Classes.== j_1)-| | |   minReads=(Right 0)-| | |   mayRaise=[ExceptionFailure]-| | | choicesBranch [\x_0 -> x_0]-| | |   minReads=(Right 0)-| | |   mayRaise=[ExceptionFailure]-| | | | <branch>-| | | | | pushValue (\x_0 -> x_0)-| | | | |   minReads=(Right 0)-| | | | |   mayRaise=[]-| | | | | ret-| | | | |   minReads=(Right 0)-| | | | |   mayRaise=[]-| | | | <default>-| | | | | fail []-| | | | |   minReads=(Left ExceptionFailure)-| | | | |   mayRaise=[ExceptionFailure]-pushValue GHC.Show.show-  minReads=(Right 1)-  mayRaise=[ExceptionFailure]-pushValue (\x_0 -> \x_1 -> x_0)-  minReads=(Right 1)-  mayRaise=[ExceptionFailure]-call <hidden>-  minReads=(Right 1)-  mayRaise=[ExceptionFailure]-pushValue GHC.Types.[]-  minReads=(Right 1)-  mayRaise=[ExceptionFailure]-lift2Value (\x_0 -> \x_1 -> x_0 x_1)-  minReads=(Right 1)-  mayRaise=[ExceptionFailure]-lift2Value (\x_0 -> \x_1 -> x_0 x_1)-  minReads=(Right 1)-  mayRaise=[ExceptionFailure]-pushValue (\x_0 -> \x_1 -> x_0)-  minReads=(Right 1)-  mayRaise=[ExceptionFailure]-pushValue 'b'-  minReads=(Right 1)-  mayRaise=[ExceptionFailure]-lift2Value (\x_0 -> \x_1 -> x_0 x_1)-  minReads=(Right 1)-  mayRaise=[ExceptionFailure]-read ((GHC.Classes.==) 'b')-  minReads=(Right 1)-  mayRaise=[ExceptionFailure]-lift2Value (\x_0 -> \x_1 -> x_0 x_1)-  minReads=(Right 0)-  mayRaise=[]-lift2Value (\x_0 -> \x_1 -> x_0 x_1)-  minReads=(Right 0)-  mayRaise=[]-lift2Value (\x_0 -> \x_1 -> x_0 x_1)-  minReads=(Right 0)-  mayRaise=[]-ret-  minReads=(Right 0)-  mayRaise=[]
− test/Golden/Machine/G12.expected.txt 
@@ -1,146 +0,0 @@-let <hidden>-  minReads=(Right 0)-  mayRaise=[ExceptionFailure]-| catch ExceptionFailure-|   minReads=(Right 0)-|   mayRaise=[ExceptionFailure]-| | <ok>-| | | pushValue (\x_0 -> \x_1 -> \x_2 -> x_0 (x_1 x_2))-| | |   minReads=(Right 1)-| | |   mayRaise=[ExceptionFailure]-| | | pushValue (GHC.Types.:)-| | |   minReads=(Right 1)-| | |   mayRaise=[ExceptionFailure]-| | | read (\t_0 -> ('a' GHC.Classes.== t_0) GHC.Classes.|| (('b' GHC.Classes.== t_0) GHC.Classes.|| (('c' GHC.Classes.== t_0) GHC.Classes.|| (('d' GHC.Classes.== t_0) GHC.Classes.|| GHC.Types.False))))-| | |   minReads=(Right 1)-| | |   mayRaise=[ExceptionFailure]-| | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | |   minReads=(Right 0)-| | |   mayRaise=[ExceptionFailure]-| | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | |   minReads=(Right 0)-| | |   mayRaise=[ExceptionFailure]-| | | call <hidden>-| | |   minReads=(Right 0)-| | |   mayRaise=[ExceptionFailure]-| | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | |   minReads=(Right 0)-| | |   mayRaise=[]-| | | commit ExceptionFailure-| | |   minReads=(Right 0)-| | |   mayRaise=[]-| | | ret-| | |   minReads=(Right 0)-| | |   mayRaise=[]-| | <ko>-| | | pushInput-| | |   minReads=(Right 0)-| | |   mayRaise=[ExceptionFailure]-| | | lift2Value (\(Data.Text.Internal.Text _ i_0 _) (Data.Text.Internal.Text _-| | |                                                                j_1-| | |                                                                _) -> i_0 GHC.Classes.== j_1)-| | |   minReads=(Right 0)-| | |   mayRaise=[ExceptionFailure]-| | | choicesBranch [\x_0 -> x_0]-| | |   minReads=(Right 0)-| | |   mayRaise=[ExceptionFailure]-| | | | <branch>-| | | | | pushValue (\x_0 -> x_0)-| | | | |   minReads=(Right 0)-| | | | |   mayRaise=[]-| | | | | ret-| | | | |   minReads=(Right 0)-| | | | |   mayRaise=[]-| | | | <default>-| | | | | fail []-| | | | |   minReads=(Left ExceptionFailure)-| | | | |   mayRaise=[ExceptionFailure]-pushValue GHC.Show.show-  minReads=(Right 0)-  mayRaise=[ExceptionFailure]-pushValue (\x_0 -> \x_1 -> x_0)-  minReads=(Right 0)-  mayRaise=[ExceptionFailure]-call <hidden>-  minReads=(Right 0)-  mayRaise=[ExceptionFailure]-pushValue GHC.Types.[]-  minReads=(Right 0)-  mayRaise=[ExceptionFailure]-lift2Value (\x_0 -> \x_1 -> x_0 x_1)-  minReads=(Right 0)-  mayRaise=[ExceptionFailure]-lift2Value (\x_0 -> \x_1 -> x_0 x_1)-  minReads=(Right 0)-  mayRaise=[ExceptionFailure]-join <hidden>-  minReads=(Right 0)-  mayRaise=[]-| lift2Value (\x_0 -> \x_1 -> x_0 x_1)-|   minReads=(Right 0)-|   mayRaise=[]-| lift2Value (\x_0 -> \x_1 -> x_0 x_1)-|   minReads=(Right 0)-|   mayRaise=[]-| ret-|   minReads=(Right 0)-|   mayRaise=[]-catch ExceptionFailure-  minReads=(Right 0)-  mayRaise=[ExceptionFailure]-| <ok>-| | catch ExceptionFailure-| |   minReads=(Right 0)-| |   mayRaise=[]-| | | <ok>-| | | | pushInput-| | | |   minReads=(Left ExceptionFailure)-| | | |   mayRaise=[ExceptionFailure]-| | | | read ((\x_0 -> \x_1 -> x_0) GHC.Types.True)-| | | |   minReads=(Left ExceptionFailure)-| | | |   mayRaise=[ExceptionFailure]-| | | | popValue-| | | |   minReads=(Left ExceptionFailure)-| | | |   mayRaise=[ExceptionFailure]-| | | | commit ExceptionFailure-| | | |   minReads=(Left ExceptionFailure)-| | | |   mayRaise=[ExceptionFailure]-| | | | loadInput-| | | |   minReads=(Left ExceptionFailure)-| | | |   mayRaise=[ExceptionFailure]-| | | | fail []-| | | |   minReads=(Left ExceptionFailure)-| | | |   mayRaise=[ExceptionFailure]-| | | <ko>-| | | | loadInput-| | | |   minReads=(Right 0)-| | | |   mayRaise=[]-| | | | pushValue GHC.Tuple.()-| | | |   minReads=(Right 0)-| | | |   mayRaise=[]-| | | | commit ExceptionFailure-| | | |   minReads=(Right 0)-| | | |   mayRaise=[]-| | | | refJoin <hidden>-| | | |   minReads=(Right 0)-| | | |   mayRaise=[]-| <ko>-| | pushInput-| |   minReads=(Left ExceptionFailure)-| |   mayRaise=[ExceptionFailure]-| | lift2Value (\(Data.Text.Internal.Text _ i_0 _) (Data.Text.Internal.Text _-| |                                                                j_1-| |                                                                _) -> i_0 GHC.Classes.== j_1)-| |   minReads=(Left ExceptionFailure)-| |   mayRaise=[ExceptionFailure]-| | choicesBranch [\x_0 -> x_0]-| |   minReads=(Left ExceptionFailure)-| |   mayRaise=[ExceptionFailure]-| | | <branch>-| | | | fail [FailureEnd]-| | | |   minReads=(Left ExceptionFailure)-| | | |   mayRaise=[ExceptionFailure]-| | | <default>-| | | | fail []-| | | |   minReads=(Left ExceptionFailure)-| | | |   mayRaise=[ExceptionFailure]
− test/Golden/Machine/G13.expected.txt 
@@ -1,416 +0,0 @@-let <hidden>-  minReads=(Right 0)-  mayRaise=[ExceptionFailure]-| call <hidden>-|   minReads=(Right 0)-|   mayRaise=[ExceptionFailure]-| pushValue GHC.Types.[]-|   minReads=(Right 0)-|   mayRaise=[]-| lift2Value (\x_0 -> \x_1 -> x_0 x_1)-|   minReads=(Right 0)-|   mayRaise=[]-| ret-|   minReads=(Right 0)-|   mayRaise=[]-let <hidden>-  minReads=(Right 0)-  mayRaise=[ExceptionFailure]-| catch ExceptionFailure-|   minReads=(Right 0)-|   mayRaise=[ExceptionFailure]-| | <ok>-| | | pushValue (\x_0 -> \x_1 -> \x_2 -> x_0 (x_1 x_2))-| | |   minReads=(Right 1)-| | |   mayRaise=[ExceptionFailure]-| | | pushValue (GHC.Types.:)-| | |   minReads=(Right 1)-| | |   mayRaise=[ExceptionFailure]-| | | pushValue (\x_0 -> \x_1 -> x_0)-| | |   minReads=(Right 1)-| | |   mayRaise=[ExceptionFailure]-| | | join <hidden>-| | |   minReads=(Right 0)-| | |   mayRaise=[ExceptionFailure]-| | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | |   minReads=(Right 0)-| | | |   mayRaise=[ExceptionFailure]-| | | | call <hidden>-| | | |   minReads=(Right 0)-| | | |   mayRaise=[ExceptionFailure]-| | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | |   minReads=(Right 0)-| | | |   mayRaise=[ExceptionFailure]-| | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | |   minReads=(Right 0)-| | | |   mayRaise=[ExceptionFailure]-| | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | |   minReads=(Right 0)-| | | |   mayRaise=[ExceptionFailure]-| | | | call <hidden>-| | | |   minReads=(Right 0)-| | | |   mayRaise=[ExceptionFailure]-| | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | |   minReads=(Right 0)-| | | |   mayRaise=[]-| | | | commit ExceptionFailure-| | | |   minReads=(Right 0)-| | | |   mayRaise=[]-| | | | ret-| | | |   minReads=(Right 0)-| | | |   mayRaise=[]-| | | pushInput-| | |   minReads=(Right 1)-| | |   mayRaise=[ExceptionFailure]-| | | read ((\x_0 -> \x_1 -> x_0) GHC.Types.True)-| | |   minReads=(Right 1)-| | |   mayRaise=[ExceptionFailure]-| | | swapValue-| | |   minReads=(Right 0)-| | |   mayRaise=[ExceptionFailure]-| | | loadInput-| | |   minReads=(Right 0)-| | |   mayRaise=[ExceptionFailure]-| | | choicesBranch [(GHC.Classes.==) '<',(GHC.Classes.==) '>',(GHC.Classes.==) '+',(GHC.Classes.==) '-',(GHC.Classes.==) ',',(GHC.Classes.==) '.',(GHC.Classes.==) '[']-| | |   minReads=(Right 1)-| | |   mayRaise=[ExceptionFailure]-| | | | <branch>-| | | | | pushValue (\x_0 -> \x_1 -> x_0)-| | | | |   minReads=(Right 1)-| | | | |   mayRaise=[ExceptionFailure]-| | | | | pushValue Parsers.Brainfuck.Types.Backward-| | | | |   minReads=(Right 1)-| | | | |   mayRaise=[ExceptionFailure]-| | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | |   minReads=(Right 1)-| | | | |   mayRaise=[ExceptionFailure]-| | | | | read ((\x_0 -> \x_1 -> x_0) GHC.Types.True)-| | | | |   minReads=(Right 1)-| | | | |   mayRaise=[ExceptionFailure]-| | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | |   minReads=(Right 0)-| | | | |   mayRaise=[]-| | | | | refJoin <hidden>-| | | | |   minReads=(Right 0)-| | | | |   mayRaise=[]-| | | | <branch>-| | | | | pushValue (\x_0 -> \x_1 -> x_0)-| | | | |   minReads=(Right 1)-| | | | |   mayRaise=[ExceptionFailure]-| | | | | pushValue Parsers.Brainfuck.Types.Forward-| | | | |   minReads=(Right 1)-| | | | |   mayRaise=[ExceptionFailure]-| | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | |   minReads=(Right 1)-| | | | |   mayRaise=[ExceptionFailure]-| | | | | read ((\x_0 -> \x_1 -> x_0) GHC.Types.True)-| | | | |   minReads=(Right 1)-| | | | |   mayRaise=[ExceptionFailure]-| | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | |   minReads=(Right 0)-| | | | |   mayRaise=[]-| | | | | refJoin <hidden>-| | | | |   minReads=(Right 0)-| | | | |   mayRaise=[]-| | | | <branch>-| | | | | pushValue (\x_0 -> \x_1 -> x_0)-| | | | |   minReads=(Right 1)-| | | | |   mayRaise=[ExceptionFailure]-| | | | | pushValue Parsers.Brainfuck.Types.Increment-| | | | |   minReads=(Right 1)-| | | | |   mayRaise=[ExceptionFailure]-| | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | |   minReads=(Right 1)-| | | | |   mayRaise=[ExceptionFailure]-| | | | | read ((\x_0 -> \x_1 -> x_0) GHC.Types.True)-| | | | |   minReads=(Right 1)-| | | | |   mayRaise=[ExceptionFailure]-| | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | |   minReads=(Right 0)-| | | | |   mayRaise=[]-| | | | | refJoin <hidden>-| | | | |   minReads=(Right 0)-| | | | |   mayRaise=[]-| | | | <branch>-| | | | | pushValue (\x_0 -> \x_1 -> x_0)-| | | | |   minReads=(Right 1)-| | | | |   mayRaise=[ExceptionFailure]-| | | | | pushValue Parsers.Brainfuck.Types.Decrement-| | | | |   minReads=(Right 1)-| | | | |   mayRaise=[ExceptionFailure]-| | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | |   minReads=(Right 1)-| | | | |   mayRaise=[ExceptionFailure]-| | | | | read ((\x_0 -> \x_1 -> x_0) GHC.Types.True)-| | | | |   minReads=(Right 1)-| | | | |   mayRaise=[ExceptionFailure]-| | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | |   minReads=(Right 0)-| | | | |   mayRaise=[]-| | | | | refJoin <hidden>-| | | | |   minReads=(Right 0)-| | | | |   mayRaise=[]-| | | | <branch>-| | | | | pushValue (\x_0 -> \x_1 -> x_0)-| | | | |   minReads=(Right 1)-| | | | |   mayRaise=[ExceptionFailure]-| | | | | pushValue Parsers.Brainfuck.Types.Input-| | | | |   minReads=(Right 1)-| | | | |   mayRaise=[ExceptionFailure]-| | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | |   minReads=(Right 1)-| | | | |   mayRaise=[ExceptionFailure]-| | | | | read ((\x_0 -> \x_1 -> x_0) GHC.Types.True)-| | | | |   minReads=(Right 1)-| | | | |   mayRaise=[ExceptionFailure]-| | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | |   minReads=(Right 0)-| | | | |   mayRaise=[]-| | | | | refJoin <hidden>-| | | | |   minReads=(Right 0)-| | | | |   mayRaise=[]-| | | | <branch>-| | | | | pushValue (\x_0 -> \x_1 -> x_0)-| | | | |   minReads=(Right 1)-| | | | |   mayRaise=[ExceptionFailure]-| | | | | pushValue Parsers.Brainfuck.Types.Output-| | | | |   minReads=(Right 1)-| | | | |   mayRaise=[ExceptionFailure]-| | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | |   minReads=(Right 1)-| | | | |   mayRaise=[ExceptionFailure]-| | | | | read ((\x_0 -> \x_1 -> x_0) GHC.Types.True)-| | | | |   minReads=(Right 1)-| | | | |   mayRaise=[ExceptionFailure]-| | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | |   minReads=(Right 0)-| | | | |   mayRaise=[]-| | | | | refJoin <hidden>-| | | | |   minReads=(Right 0)-| | | | |   mayRaise=[]-| | | | <branch>-| | | | | pushValue (\x_0 -> \x_1 -> x_0)-| | | | |   minReads=(Right 2)-| | | | |   mayRaise=[ExceptionFailure]-| | | | | pushValue (\x_0 -> \x_1 -> x_0)-| | | | |   minReads=(Right 2)-| | | | |   mayRaise=[ExceptionFailure]-| | | | | pushValue (\x_0 -> x_0)-| | | | |   minReads=(Right 2)-| | | | |   mayRaise=[ExceptionFailure]-| | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | |   minReads=(Right 2)-| | | | |   mayRaise=[ExceptionFailure]-| | | | | pushValue (\x_0 -> \x_1 -> x_0)-| | | | |   minReads=(Right 2)-| | | | |   mayRaise=[ExceptionFailure]-| | | | | read ((\x_0 -> \x_1 -> x_0) GHC.Types.True)-| | | | |   minReads=(Right 2)-| | | | |   mayRaise=[ExceptionFailure]-| | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | |   minReads=(Right 1)-| | | | |   mayRaise=[ExceptionFailure]-| | | | | call <hidden>-| | | | |   minReads=(Right 1)-| | | | |   mayRaise=[ExceptionFailure]-| | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | |   minReads=(Right 1)-| | | | |   mayRaise=[ExceptionFailure]-| | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | |   minReads=(Right 1)-| | | | |   mayRaise=[ExceptionFailure]-| | | | | pushValue Parsers.Brainfuck.Types.Loop-| | | | |   minReads=(Right 1)-| | | | |   mayRaise=[ExceptionFailure]-| | | | | call <hidden>-| | | | |   minReads=(Right 1)-| | | | |   mayRaise=[ExceptionFailure]-| | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | |   minReads=(Right 1)-| | | | |   mayRaise=[ExceptionFailure]-| | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | |   minReads=(Right 1)-| | | | |   mayRaise=[ExceptionFailure]-| | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | |   minReads=(Right 1)-| | | | |   mayRaise=[ExceptionFailure]-| | | | | pushValue (\x_0 -> \x_1 -> x_0)-| | | | |   minReads=(Right 1)-| | | | |   mayRaise=[ExceptionFailure]-| | | | | pushValue ']'-| | | | |   minReads=(Right 1)-| | | | |   mayRaise=[ExceptionFailure]-| | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | |   minReads=(Right 1)-| | | | |   mayRaise=[ExceptionFailure]-| | | | | read ((GHC.Classes.==) ']')-| | | | |   minReads=(Right 1)-| | | | |   mayRaise=[ExceptionFailure]-| | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | |   minReads=(Right 0)-| | | | |   mayRaise=[]-| | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | |   minReads=(Right 0)-| | | | |   mayRaise=[]-| | | | | refJoin <hidden>-| | | | |   minReads=(Right 0)-| | | | |   mayRaise=[]-| | | | <default>-| | | | | fail [FailureEmpty]-| | | | |   minReads=(Left ExceptionFailure)-| | | | |   mayRaise=[ExceptionFailure]-| | <ko>-| | | pushInput-| | |   minReads=(Right 0)-| | |   mayRaise=[ExceptionFailure]-| | | lift2Value (\(Data.Text.Internal.Text _ i_0 _) (Data.Text.Internal.Text _-| | |                                                                j_1-| | |                                                                _) -> i_0 GHC.Classes.== j_1)-| | |   minReads=(Right 0)-| | |   mayRaise=[ExceptionFailure]-| | | choicesBranch [\x_0 -> x_0]-| | |   minReads=(Right 0)-| | |   mayRaise=[ExceptionFailure]-| | | | <branch>-| | | | | pushValue (\x_0 -> x_0)-| | | | |   minReads=(Right 0)-| | | | |   mayRaise=[]-| | | | | ret-| | | | |   minReads=(Right 0)-| | | | |   mayRaise=[]-| | | | <default>-| | | | | fail []-| | | | |   minReads=(Left ExceptionFailure)-| | | | |   mayRaise=[ExceptionFailure]-let <hidden>-  minReads=(Right 0)-  mayRaise=[ExceptionFailure]-| catch ExceptionFailure-|   minReads=(Right 0)-|   mayRaise=[ExceptionFailure]-| | <ok>-| | | pushValue (\x_0 -> \x_1 -> \x_2 -> x_0 (x_1 x_2))-| | |   minReads=(Right 1)-| | |   mayRaise=[ExceptionFailure]-| | | pushValue (\x_0 -> \x_1 -> \x_2 -> x_0 x_2 x_1)-| | |   minReads=(Right 1)-| | |   mayRaise=[ExceptionFailure]-| | | pushValue (\x_0 -> \x_1 -> x_0)-| | |   minReads=(Right 1)-| | |   mayRaise=[ExceptionFailure]-| | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | |   minReads=(Right 1)-| | |   mayRaise=[ExceptionFailure]-| | | read (\c_0 -> GHC.Classes.not (('<' GHC.Classes.== c_0) GHC.Classes.|| (('>' GHC.Classes.== c_0) GHC.Classes.|| (('+' GHC.Classes.== c_0) GHC.Classes.|| (('-' GHC.Classes.== c_0) GHC.Classes.|| ((',' GHC.Classes.== c_0) GHC.Classes.|| (('.' GHC.Classes.== c_0) GHC.Classes.|| (('[' GHC.Classes.== c_0) GHC.Classes.|| ((']' GHC.Classes.== c_0) GHC.Classes.|| GHC.Types.False)))))))))-| | |   minReads=(Right 1)-| | |   mayRaise=[ExceptionFailure]-| | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | |   minReads=(Right 0)-| | |   mayRaise=[ExceptionFailure]-| | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | |   minReads=(Right 0)-| | |   mayRaise=[ExceptionFailure]-| | | call <hidden>-| | |   minReads=(Right 0)-| | |   mayRaise=[ExceptionFailure]-| | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | |   minReads=(Right 0)-| | |   mayRaise=[]-| | | commit ExceptionFailure-| | |   minReads=(Right 0)-| | |   mayRaise=[]-| | | ret-| | |   minReads=(Right 0)-| | |   mayRaise=[]-| | <ko>-| | | pushInput-| | |   minReads=(Right 0)-| | |   mayRaise=[ExceptionFailure]-| | | lift2Value (\(Data.Text.Internal.Text _ i_0 _) (Data.Text.Internal.Text _-| | |                                                                j_1-| | |                                                                _) -> i_0 GHC.Classes.== j_1)-| | |   minReads=(Right 0)-| | |   mayRaise=[ExceptionFailure]-| | | choicesBranch [\x_0 -> x_0]-| | |   minReads=(Right 0)-| | |   mayRaise=[ExceptionFailure]-| | | | <branch>-| | | | | pushValue (\x_0 -> x_0)-| | | | |   minReads=(Right 0)-| | | | |   mayRaise=[]-| | | | | ret-| | | | |   minReads=(Right 0)-| | | | |   mayRaise=[]-| | | | <default>-| | | | | fail []-| | | | |   minReads=(Left ExceptionFailure)-| | | | |   mayRaise=[ExceptionFailure]-let <hidden>-  minReads=(Right 0)-  mayRaise=[ExceptionFailure]-| pushValue (\x_0 -> \x_1 -> x_0)-|   minReads=(Right 0)-|   mayRaise=[ExceptionFailure]-| pushValue (\x_0 -> x_0)-|   minReads=(Right 0)-|   mayRaise=[ExceptionFailure]-| lift2Value (\x_0 -> \x_1 -> x_0 x_1)-|   minReads=(Right 0)-|   mayRaise=[ExceptionFailure]-| pushValue ((\x_0 -> \x_1 -> \x_2 -> x_0 x_2 x_1) (\x_3 -> \x_4 -> x_3 x_4))-|   minReads=(Right 0)-|   mayRaise=[ExceptionFailure]-| pushValue GHC.Tuple.()-|   minReads=(Right 0)-|   mayRaise=[ExceptionFailure]-| lift2Value (\x_0 -> \x_1 -> x_0 x_1)-|   minReads=(Right 0)-|   mayRaise=[ExceptionFailure]-| call <hidden>-|   minReads=(Right 0)-|   mayRaise=[ExceptionFailure]-| lift2Value (\x_0 -> \x_1 -> x_0 x_1)-|   minReads=(Right 0)-|   mayRaise=[]-| lift2Value (\x_0 -> \x_1 -> x_0 x_1)-|   minReads=(Right 0)-|   mayRaise=[]-| pushValue GHC.Tuple.()-|   minReads=(Right 0)-|   mayRaise=[]-| lift2Value (\x_0 -> \x_1 -> x_0 x_1)-|   minReads=(Right 0)-|   mayRaise=[]-| ret-|   minReads=(Right 0)-|   mayRaise=[]-pushValue GHC.Show.show-  minReads=(Right 0)-  mayRaise=[ExceptionFailure]-pushValue (\x_0 -> \x_1 -> x_0)-  minReads=(Right 0)-  mayRaise=[ExceptionFailure]-pushValue (\x_0 -> x_0)-  minReads=(Right 0)-  mayRaise=[ExceptionFailure]-lift2Value (\x_0 -> \x_1 -> x_0 x_1)-  minReads=(Right 0)-  mayRaise=[ExceptionFailure]-call <hidden>-  minReads=(Right 0)-  mayRaise=[ExceptionFailure]-lift2Value (\x_0 -> \x_1 -> x_0 x_1)-  minReads=(Right 0)-  mayRaise=[ExceptionFailure]-call <hidden>-  minReads=(Right 0)-  mayRaise=[ExceptionFailure]-lift2Value (\x_0 -> \x_1 -> x_0 x_1)-  minReads=(Right 0)-  mayRaise=[]-lift2Value (\x_0 -> \x_1 -> x_0 x_1)-  minReads=(Right 0)-  mayRaise=[]-ret-  minReads=(Right 0)-  mayRaise=[]
− test/Golden/Machine/G14.expected.txt 
@@ -1,3383 +0,0 @@-let <hidden>-  minReads=(Right 0)-  mayRaise=[ExceptionFailure]-| catch ExceptionFailure-|   minReads=(Right 0)-|   mayRaise=[ExceptionFailure]-| | <ok>-| | | pushValue (\x_0 -> \x_1 -> \x_2 -> x_0 (x_1 x_2))-| | |   minReads=(Right 1)-| | |   mayRaise=[ExceptionFailure]-| | | pushValue (\x_0 -> \x_1 -> \x_2 -> x_0 x_2 x_1)-| | |   minReads=(Right 1)-| | |   mayRaise=[ExceptionFailure]-| | | pushValue (\x_0 -> \x_1 -> x_0)-| | |   minReads=(Right 1)-| | |   mayRaise=[ExceptionFailure]-| | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | |   minReads=(Right 1)-| | |   mayRaise=[ExceptionFailure]-| | | call <hidden>-| | |   minReads=(Right 1)-| | |   mayRaise=[ExceptionFailure]-| | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | |   minReads=(Right 0)-| | |   mayRaise=[ExceptionFailure]-| | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | |   minReads=(Right 0)-| | |   mayRaise=[ExceptionFailure]-| | | call <hidden>-| | |   minReads=(Right 0)-| | |   mayRaise=[ExceptionFailure]-| | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | |   minReads=(Right 0)-| | |   mayRaise=[]-| | | commit ExceptionFailure-| | |   minReads=(Right 0)-| | |   mayRaise=[]-| | | ret-| | |   minReads=(Right 0)-| | |   mayRaise=[]-| | <ko>-| | | pushInput-| | |   minReads=(Right 0)-| | |   mayRaise=[ExceptionFailure]-| | | lift2Value (\(Data.Text.Internal.Text _ i_0 _) (Data.Text.Internal.Text _-| | |                                                                j_1-| | |                                                                _) -> i_0 GHC.Classes.== j_1)-| | |   minReads=(Right 0)-| | |   mayRaise=[ExceptionFailure]-| | | choicesBranch [\x_0 -> x_0]-| | |   minReads=(Right 0)-| | |   mayRaise=[ExceptionFailure]-| | | | <branch>-| | | | | pushValue (\x_0 -> x_0)-| | | | |   minReads=(Right 0)-| | | | |   mayRaise=[]-| | | | | ret-| | | | |   minReads=(Right 0)-| | | | |   mayRaise=[]-| | | | <default>-| | | | | fail []-| | | | |   minReads=(Left ExceptionFailure)-| | | | |   mayRaise=[ExceptionFailure]-let <hidden>-  minReads=(Right 0)-  mayRaise=[ExceptionFailure]-| catch ExceptionFailure-|   minReads=(Right 0)-|   mayRaise=[ExceptionFailure]-| | <ok>-| | | pushValue (\x_0 -> \x_1 -> \x_2 -> x_0 (x_1 x_2))-| | |   minReads=(Right 1)-| | |   mayRaise=[ExceptionFailure]-| | | pushValue (\x_0 -> \x_1 -> \x_2 -> x_0 x_2 x_1)-| | |   minReads=(Right 1)-| | |   mayRaise=[ExceptionFailure]-| | | pushValue (\x_0 -> \x_1 -> x_0)-| | |   minReads=(Right 1)-| | |   mayRaise=[ExceptionFailure]-| | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | |   minReads=(Right 1)-| | |   mayRaise=[ExceptionFailure]-| | | call <hidden>-| | |   minReads=(Right 1)-| | |   mayRaise=[ExceptionFailure]-| | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | |   minReads=(Right 0)-| | |   mayRaise=[ExceptionFailure]-| | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | |   minReads=(Right 0)-| | |   mayRaise=[ExceptionFailure]-| | | call <hidden>-| | |   minReads=(Right 0)-| | |   mayRaise=[ExceptionFailure]-| | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | |   minReads=(Right 0)-| | |   mayRaise=[]-| | | commit ExceptionFailure-| | |   minReads=(Right 0)-| | |   mayRaise=[]-| | | ret-| | |   minReads=(Right 0)-| | |   mayRaise=[]-| | <ko>-| | | pushInput-| | |   minReads=(Right 0)-| | |   mayRaise=[ExceptionFailure]-| | | lift2Value (\(Data.Text.Internal.Text _ i_0 _) (Data.Text.Internal.Text _-| | |                                                                j_1-| | |                                                                _) -> i_0 GHC.Classes.== j_1)-| | |   minReads=(Right 0)-| | |   mayRaise=[ExceptionFailure]-| | | choicesBranch [\x_0 -> x_0]-| | |   minReads=(Right 0)-| | |   mayRaise=[ExceptionFailure]-| | | | <branch>-| | | | | pushValue (\x_0 -> x_0)-| | | | |   minReads=(Right 0)-| | | | |   mayRaise=[]-| | | | | ret-| | | | |   minReads=(Right 0)-| | | | |   mayRaise=[]-| | | | <default>-| | | | | fail []-| | | | |   minReads=(Left ExceptionFailure)-| | | | |   mayRaise=[ExceptionFailure]-let <hidden>-  minReads=(Right 0)-  mayRaise=[ExceptionFailure]-| catch ExceptionFailure-|   minReads=(Right 0)-|   mayRaise=[ExceptionFailure]-| | <ok>-| | | pushValue (\x_0 -> \x_1 -> \x_2 -> x_0 (x_1 x_2))-| | |   minReads=(Right 1)-| | |   mayRaise=[ExceptionFailure]-| | | pushValue (\x_0 -> \x_1 -> \x_2 -> x_0 x_2 x_1)-| | |   minReads=(Right 1)-| | |   mayRaise=[ExceptionFailure]-| | | pushValue (\x_0 -> \x_1 -> x_0)-| | |   minReads=(Right 1)-| | |   mayRaise=[ExceptionFailure]-| | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | |   minReads=(Right 1)-| | |   mayRaise=[ExceptionFailure]-| | | read Parsers.Nandlang.nandIdentLetter-| | |   minReads=(Right 1)-| | |   mayRaise=[ExceptionFailure]-| | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | |   minReads=(Right 0)-| | |   mayRaise=[ExceptionFailure]-| | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | |   minReads=(Right 0)-| | |   mayRaise=[ExceptionFailure]-| | | call <hidden>-| | |   minReads=(Right 0)-| | |   mayRaise=[ExceptionFailure]-| | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | |   minReads=(Right 0)-| | |   mayRaise=[]-| | | commit ExceptionFailure-| | |   minReads=(Right 0)-| | |   mayRaise=[]-| | | ret-| | |   minReads=(Right 0)-| | |   mayRaise=[]-| | <ko>-| | | pushInput-| | |   minReads=(Right 0)-| | |   mayRaise=[ExceptionFailure]-| | | lift2Value (\(Data.Text.Internal.Text _ i_0 _) (Data.Text.Internal.Text _-| | |                                                                j_1-| | |                                                                _) -> i_0 GHC.Classes.== j_1)-| | |   minReads=(Right 0)-| | |   mayRaise=[ExceptionFailure]-| | | choicesBranch [\x_0 -> x_0]-| | |   minReads=(Right 0)-| | |   mayRaise=[ExceptionFailure]-| | | | <branch>-| | | | | pushValue (\x_0 -> x_0)-| | | | |   minReads=(Right 0)-| | | | |   mayRaise=[]-| | | | | ret-| | | | |   minReads=(Right 0)-| | | | |   mayRaise=[]-| | | | <default>-| | | | | fail []-| | | | |   minReads=(Left ExceptionFailure)-| | | | |   mayRaise=[ExceptionFailure]-let <hidden>-  minReads=(Right 0)-  mayRaise=[ExceptionFailure]-| catch ExceptionFailure-|   minReads=(Right 0)-|   mayRaise=[ExceptionFailure]-| | <ok>-| | | pushValue (\x_0 -> \x_1 -> \x_2 -> x_0 (x_1 x_2))-| | |   minReads=(Right 18)-| | |   mayRaise=[ExceptionFailure]-| | | pushValue (\x_0 -> \x_1 -> \x_2 -> x_0 x_2 x_1)-| | |   minReads=(Right 18)-| | |   mayRaise=[ExceptionFailure]-| | | pushValue (\x_0 -> \x_1 -> x_0)-| | |   minReads=(Right 18)-| | |   mayRaise=[ExceptionFailure]-| | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | |   minReads=(Right 18)-| | |   mayRaise=[ExceptionFailure]-| | | pushValue (\x_0 -> \x_1 -> x_0)-| | |   minReads=(Right 18)-| | |   mayRaise=[ExceptionFailure]-| | | pushValue (\x_0 -> x_0)-| | |   minReads=(Right 18)-| | |   mayRaise=[ExceptionFailure]-| | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | |   minReads=(Right 18)-| | |   mayRaise=[ExceptionFailure]-| | | pushValue (\x_0 -> \x_1 -> x_0)-| | |   minReads=(Right 18)-| | |   mayRaise=[ExceptionFailure]-| | | pushValue (\x_0 -> x_0)-| | |   minReads=(Right 18)-| | |   mayRaise=[ExceptionFailure]-| | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | |   minReads=(Right 18)-| | |   mayRaise=[ExceptionFailure]-| | | pushValue (\x_0 -> \x_1 -> x_0)-| | |   minReads=(Right 18)-| | |   mayRaise=[ExceptionFailure]-| | | pushValue (\x_0 -> x_0)-| | |   minReads=(Right 18)-| | |   mayRaise=[ExceptionFailure]-| | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | |   minReads=(Right 18)-| | |   mayRaise=[ExceptionFailure]-| | | pushValue (\x_0 -> \x_1 -> x_0)-| | |   minReads=(Right 18)-| | |   mayRaise=[ExceptionFailure]-| | | pushValue (\x_0 -> x_0)-| | |   minReads=(Right 18)-| | |   mayRaise=[ExceptionFailure]-| | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | |   minReads=(Right 18)-| | |   mayRaise=[ExceptionFailure]-| | | catch ExceptionFailure-| | |   minReads=(Right 18)-| | |   mayRaise=[ExceptionFailure]-| | | | <ok>-| | | | | pushValue (GHC.Types.:)-| | | | |   minReads=(Right 18)-| | | | |   mayRaise=[ExceptionFailure]-| | | | | pushValue (\x_0 -> \x_1 -> x_0)-| | | | |   minReads=(Right 18)-| | | | |   mayRaise=[ExceptionFailure]-| | | | | pushValue 'f'-| | | | |   minReads=(Right 18)-| | | | |   mayRaise=[ExceptionFailure]-| | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | |   minReads=(Right 18)-| | | | |   mayRaise=[ExceptionFailure]-| | | | | read ((GHC.Classes.==) 'f')-| | | | |   minReads=(Right 18)-| | | | |   mayRaise=[ExceptionFailure]-| | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | |   minReads=(Right 17)-| | | | |   mayRaise=[ExceptionFailure]-| | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | |   minReads=(Right 17)-| | | | |   mayRaise=[ExceptionFailure]-| | | | | pushValue (GHC.Types.:)-| | | | |   minReads=(Right 17)-| | | | |   mayRaise=[ExceptionFailure]-| | | | | pushValue (\x_0 -> \x_1 -> x_0)-| | | | |   minReads=(Right 17)-| | | | |   mayRaise=[ExceptionFailure]-| | | | | pushValue 'u'-| | | | |   minReads=(Right 17)-| | | | |   mayRaise=[ExceptionFailure]-| | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | |   minReads=(Right 17)-| | | | |   mayRaise=[ExceptionFailure]-| | | | | read ((GHC.Classes.==) 'u')-| | | | |   minReads=(Right 17)-| | | | |   mayRaise=[ExceptionFailure]-| | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | |   minReads=(Right 16)-| | | | |   mayRaise=[ExceptionFailure]-| | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | |   minReads=(Right 16)-| | | | |   mayRaise=[ExceptionFailure]-| | | | | pushValue (GHC.Types.:)-| | | | |   minReads=(Right 16)-| | | | |   mayRaise=[ExceptionFailure]-| | | | | pushValue (\x_0 -> \x_1 -> x_0)-| | | | |   minReads=(Right 16)-| | | | |   mayRaise=[ExceptionFailure]-| | | | | pushValue 'n'-| | | | |   minReads=(Right 16)-| | | | |   mayRaise=[ExceptionFailure]-| | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | |   minReads=(Right 16)-| | | | |   mayRaise=[ExceptionFailure]-| | | | | read ((GHC.Classes.==) 'n')-| | | | |   minReads=(Right 16)-| | | | |   mayRaise=[ExceptionFailure]-| | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | |   minReads=(Right 15)-| | | | |   mayRaise=[ExceptionFailure]-| | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | |   minReads=(Right 15)-| | | | |   mayRaise=[ExceptionFailure]-| | | | | pushValue (GHC.Types.:)-| | | | |   minReads=(Right 15)-| | | | |   mayRaise=[ExceptionFailure]-| | | | | pushValue (\x_0 -> \x_1 -> x_0)-| | | | |   minReads=(Right 15)-| | | | |   mayRaise=[ExceptionFailure]-| | | | | pushValue 'c'-| | | | |   minReads=(Right 15)-| | | | |   mayRaise=[ExceptionFailure]-| | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | |   minReads=(Right 15)-| | | | |   mayRaise=[ExceptionFailure]-| | | | | read ((GHC.Classes.==) 'c')-| | | | |   minReads=(Right 15)-| | | | |   mayRaise=[ExceptionFailure]-| | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | |   minReads=(Right 14)-| | | | |   mayRaise=[ExceptionFailure]-| | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | |   minReads=(Right 14)-| | | | |   mayRaise=[ExceptionFailure]-| | | | | pushValue (GHC.Types.:)-| | | | |   minReads=(Right 14)-| | | | |   mayRaise=[ExceptionFailure]-| | | | | pushValue (\x_0 -> \x_1 -> x_0)-| | | | |   minReads=(Right 14)-| | | | |   mayRaise=[ExceptionFailure]-| | | | | pushValue 't'-| | | | |   minReads=(Right 14)-| | | | |   mayRaise=[ExceptionFailure]-| | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | |   minReads=(Right 14)-| | | | |   mayRaise=[ExceptionFailure]-| | | | | read ((GHC.Classes.==) 't')-| | | | |   minReads=(Right 14)-| | | | |   mayRaise=[ExceptionFailure]-| | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | |   minReads=(Right 13)-| | | | |   mayRaise=[ExceptionFailure]-| | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | |   minReads=(Right 13)-| | | | |   mayRaise=[ExceptionFailure]-| | | | | pushValue (GHC.Types.:)-| | | | |   minReads=(Right 13)-| | | | |   mayRaise=[ExceptionFailure]-| | | | | pushValue (\x_0 -> \x_1 -> x_0)-| | | | |   minReads=(Right 13)-| | | | |   mayRaise=[ExceptionFailure]-| | | | | pushValue 'i'-| | | | |   minReads=(Right 13)-| | | | |   mayRaise=[ExceptionFailure]-| | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | |   minReads=(Right 13)-| | | | |   mayRaise=[ExceptionFailure]-| | | | | read ((GHC.Classes.==) 'i')-| | | | |   minReads=(Right 13)-| | | | |   mayRaise=[ExceptionFailure]-| | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | |   minReads=(Right 12)-| | | | |   mayRaise=[ExceptionFailure]-| | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | |   minReads=(Right 12)-| | | | |   mayRaise=[ExceptionFailure]-| | | | | pushValue (GHC.Types.:)-| | | | |   minReads=(Right 12)-| | | | |   mayRaise=[ExceptionFailure]-| | | | | pushValue (\x_0 -> \x_1 -> x_0)-| | | | |   minReads=(Right 12)-| | | | |   mayRaise=[ExceptionFailure]-| | | | | pushValue 'o'-| | | | |   minReads=(Right 12)-| | | | |   mayRaise=[ExceptionFailure]-| | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | |   minReads=(Right 12)-| | | | |   mayRaise=[ExceptionFailure]-| | | | | read ((GHC.Classes.==) 'o')-| | | | |   minReads=(Right 12)-| | | | |   mayRaise=[ExceptionFailure]-| | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | |   minReads=(Right 11)-| | | | |   mayRaise=[ExceptionFailure]-| | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | |   minReads=(Right 11)-| | | | |   mayRaise=[ExceptionFailure]-| | | | | pushValue (GHC.Types.:)-| | | | |   minReads=(Right 11)-| | | | |   mayRaise=[ExceptionFailure]-| | | | | pushValue (\x_0 -> \x_1 -> x_0)-| | | | |   minReads=(Right 11)-| | | | |   mayRaise=[ExceptionFailure]-| | | | | pushValue 'n'-| | | | |   minReads=(Right 11)-| | | | |   mayRaise=[ExceptionFailure]-| | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | |   minReads=(Right 11)-| | | | |   mayRaise=[ExceptionFailure]-| | | | | read ((GHC.Classes.==) 'n')-| | | | |   minReads=(Right 11)-| | | | |   mayRaise=[ExceptionFailure]-| | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | |   minReads=(Right 10)-| | | | |   mayRaise=[ExceptionFailure]-| | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | |   minReads=(Right 10)-| | | | |   mayRaise=[ExceptionFailure]-| | | | | pushValue GHC.Types.[]-| | | | |   minReads=(Right 10)-| | | | |   mayRaise=[ExceptionFailure]-| | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | |   minReads=(Right 10)-| | | | |   mayRaise=[ExceptionFailure]-| | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | |   minReads=(Right 10)-| | | | |   mayRaise=[ExceptionFailure]-| | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | |   minReads=(Right 10)-| | | | |   mayRaise=[ExceptionFailure]-| | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | |   minReads=(Right 10)-| | | | |   mayRaise=[ExceptionFailure]-| | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | |   minReads=(Right 10)-| | | | |   mayRaise=[ExceptionFailure]-| | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | |   minReads=(Right 10)-| | | | |   mayRaise=[ExceptionFailure]-| | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | |   minReads=(Right 10)-| | | | |   mayRaise=[ExceptionFailure]-| | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | |   minReads=(Right 10)-| | | | |   mayRaise=[ExceptionFailure]-| | | | | commit ExceptionFailure-| | | | |   minReads=(Right 10)-| | | | |   mayRaise=[ExceptionFailure]-| | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | |   minReads=(Right 10)-| | | | |   mayRaise=[ExceptionFailure]-| | | | | call <hidden>-| | | | |   minReads=(Right 10)-| | | | |   mayRaise=[ExceptionFailure]-| | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | |   minReads=(Right 10)-| | | | |   mayRaise=[ExceptionFailure]-| | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | |   minReads=(Right 10)-| | | | |   mayRaise=[ExceptionFailure]-| | | | | call <hidden>-| | | | |   minReads=(Right 10)-| | | | |   mayRaise=[ExceptionFailure]-| | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | |   minReads=(Right 8)-| | | | |   mayRaise=[ExceptionFailure]-| | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | |   minReads=(Right 8)-| | | | |   mayRaise=[ExceptionFailure]-| | | | | pushValue (\x_0 -> \x_1 -> x_0)-| | | | |   minReads=(Right 8)-| | | | |   mayRaise=[ExceptionFailure]-| | | | | pushValue (\x_0 -> \x_1 -> x_0)-| | | | |   minReads=(Right 8)-| | | | |   mayRaise=[ExceptionFailure]-| | | | | pushValue (\x_0 -> x_0)-| | | | |   minReads=(Right 8)-| | | | |   mayRaise=[ExceptionFailure]-| | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | |   minReads=(Right 8)-| | | | |   mayRaise=[ExceptionFailure]-| | | | | call <hidden>-| | | | |   minReads=(Right 8)-| | | | |   mayRaise=[ExceptionFailure]-| | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | |   minReads=(Right 6)-| | | | |   mayRaise=[ExceptionFailure]-| | | | | pushValue (\x_0 -> \x_1 -> x_0)-| | | | |   minReads=(Right 6)-| | | | |   mayRaise=[ExceptionFailure]-| | | | | pushValue (\x_0 -> x_0)-| | | | |   minReads=(Right 6)-| | | | |   mayRaise=[ExceptionFailure]-| | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | |   minReads=(Right 6)-| | | | |   mayRaise=[ExceptionFailure]-| | | | | call <hidden>-| | | | |   minReads=(Right 6)-| | | | |   mayRaise=[ExceptionFailure]-| | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | |   minReads=(Right 2)-| | | | |   mayRaise=[ExceptionFailure]-| | | | | join <hidden>-| | | | |   minReads=(Right 6)-| | | | |   mayRaise=[ExceptionFailure]-| | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | | |   minReads=(Right 6)-| | | | | |   mayRaise=[ExceptionFailure]-| | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | | |   minReads=(Right 6)-| | | | | |   mayRaise=[ExceptionFailure]-| | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | | |   minReads=(Right 6)-| | | | | |   mayRaise=[ExceptionFailure]-| | | | | | call <hidden>-| | | | | |   minReads=(Right 6)-| | | | | |   mayRaise=[ExceptionFailure]-| | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | | |   minReads=(Right 4)-| | | | | |   mayRaise=[ExceptionFailure]-| | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | | |   minReads=(Right 4)-| | | | | |   mayRaise=[ExceptionFailure]-| | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | | |   minReads=(Right 4)-| | | | | |   mayRaise=[ExceptionFailure]-| | | | | | call <hidden>-| | | | | |   minReads=(Right 4)-| | | | | |   mayRaise=[ExceptionFailure]-| | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | | |   minReads=(Right 0)-| | | | | |   mayRaise=[ExceptionFailure]-| | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | | |   minReads=(Right 0)-| | | | | |   mayRaise=[ExceptionFailure]-| | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | | |   minReads=(Right 0)-| | | | | |   mayRaise=[ExceptionFailure]-| | | | | | call <hidden>-| | | | | |   minReads=(Right 0)-| | | | | |   mayRaise=[ExceptionFailure]-| | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | | |   minReads=(Right 0)-| | | | | |   mayRaise=[]-| | | | | | commit ExceptionFailure-| | | | | |   minReads=(Right 0)-| | | | | |   mayRaise=[]-| | | | | | ret-| | | | | |   minReads=(Right 0)-| | | | | |   mayRaise=[]-| | | | | catch ExceptionFailure-| | | | |   minReads=(Right 0)-| | | | |   mayRaise=[ExceptionFailure]-| | | | | | <ok>-| | | | | | | pushValue (\x_0 -> \x_1 -> x_0)-| | | | | | |   minReads=(Right 2)-| | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | pushValue GHC.Tuple.()-| | | | | | |   minReads=(Right 2)-| | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | | | |   minReads=(Right 2)-| | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | pushValue (\x_0 -> \x_1 -> x_0)-| | | | | | |   minReads=(Right 2)-| | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | pushValue (\x_0 -> x_0)-| | | | | | |   minReads=(Right 2)-| | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | | | |   minReads=(Right 2)-| | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | pushValue (\x_0 -> \x_1 -> x_0)-| | | | | | |   minReads=(Right 2)-| | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | pushValue (\x_0 -> \x_1 -> x_0)-| | | | | | |   minReads=(Right 2)-| | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | pushValue ':'-| | | | | | |   minReads=(Right 2)-| | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | | | |   minReads=(Right 2)-| | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | read ((GHC.Classes.==) ':')-| | | | | | |   minReads=(Right 2)-| | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | | | |   minReads=(Right 1)-| | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | | | |   minReads=(Right 1)-| | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | call <hidden>-| | | | | | |   minReads=(Right 1)-| | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | | | |   minReads=(Right 0)-| | | | | | |   mayRaise=[]-| | | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | | | |   minReads=(Right 0)-| | | | | | |   mayRaise=[]-| | | | | | | call <hidden>-| | | | | | |   minReads=(Right 0)-| | | | | | |   mayRaise=[]-| | | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | | | |   minReads=(Right 0)-| | | | | | |   mayRaise=[]-| | | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | | | |   minReads=(Right 0)-| | | | | | |   mayRaise=[]-| | | | | | | commit ExceptionFailure-| | | | | | |   minReads=(Right 0)-| | | | | | |   mayRaise=[]-| | | | | | | refJoin <hidden>-| | | | | | |   minReads=(Right 0)-| | | | | | |   mayRaise=[]-| | | | | | <ko>-| | | | | | | pushInput-| | | | | | |   minReads=(Right 0)-| | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | lift2Value (\(Data.Text.Internal.Text _ i_0 _) (Data.Text.Internal.Text _-| | | | | | |                                                                j_1-| | | | | | |                                                                _) -> i_0 GHC.Classes.== j_1)-| | | | | | |   minReads=(Right 0)-| | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | choicesBranch [\x_0 -> x_0]-| | | | | | |   minReads=(Right 0)-| | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | <branch>-| | | | | | | | | call <hidden>-| | | | | | | | |   minReads=(Right 0)-| | | | | | | | |   mayRaise=[]-| | | | | | | | | refJoin <hidden>-| | | | | | | | |   minReads=(Right 0)-| | | | | | | | |   mayRaise=[]-| | | | | | | | <default>-| | | | | | | | | fail []-| | | | | | | | |   minReads=(Left ExceptionFailure)-| | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | <ko>-| | | | | loadInput-| | | | |   minReads=(Left ExceptionFailure)-| | | | |   mayRaise=[ExceptionFailure]-| | | | | fail []-| | | | |   minReads=(Left ExceptionFailure)-| | | | |   mayRaise=[ExceptionFailure]-| | <ko>-| | | pushInput-| | |   minReads=(Right 0)-| | |   mayRaise=[ExceptionFailure]-| | | lift2Value (\(Data.Text.Internal.Text _ i_0 _) (Data.Text.Internal.Text _-| | |                                                                j_1-| | |                                                                _) -> i_0 GHC.Classes.== j_1)-| | |   minReads=(Right 0)-| | |   mayRaise=[ExceptionFailure]-| | | choicesBranch [\x_0 -> x_0]-| | |   minReads=(Right 0)-| | |   mayRaise=[ExceptionFailure]-| | | | <branch>-| | | | | pushValue (\x_0 -> x_0)-| | | | |   minReads=(Right 0)-| | | | |   mayRaise=[]-| | | | | ret-| | | | |   minReads=(Right 0)-| | | | |   mayRaise=[]-| | | | <default>-| | | | | fail []-| | | | |   minReads=(Left ExceptionFailure)-| | | | |   mayRaise=[ExceptionFailure]-let <hidden>-  minReads=(Right 0)-  mayRaise=[ExceptionFailure]-| catch ExceptionFailure-|   minReads=(Right 0)-|   mayRaise=[ExceptionFailure]-| | <ok>-| | | pushValue (\x_0 -> \x_1 -> \x_2 -> x_0 (x_1 x_2))-| | |   minReads=(Right 2)-| | |   mayRaise=[ExceptionFailure]-| | | pushValue (\x_0 -> \x_1 -> \x_2 -> x_0 x_2 x_1)-| | |   minReads=(Right 2)-| | |   mayRaise=[ExceptionFailure]-| | | pushValue (\x_0 -> \x_1 -> x_0)-| | |   minReads=(Right 2)-| | |   mayRaise=[ExceptionFailure]-| | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | |   minReads=(Right 2)-| | |   mayRaise=[ExceptionFailure]-| | | join <hidden>-| | |   minReads=(Right 0)-| | |   mayRaise=[ExceptionFailure]-| | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | |   minReads=(Right 0)-| | | |   mayRaise=[ExceptionFailure]-| | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | |   minReads=(Right 0)-| | | |   mayRaise=[ExceptionFailure]-| | | | call <hidden>-| | | |   minReads=(Right 0)-| | | |   mayRaise=[ExceptionFailure]-| | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | |   minReads=(Right 0)-| | | |   mayRaise=[]-| | | | commit ExceptionFailure-| | | |   minReads=(Right 0)-| | | |   mayRaise=[]-| | | | ret-| | | |   minReads=(Right 0)-| | | |   mayRaise=[]-| | | catch ExceptionFailure-| | |   minReads=(Right 2)-| | |   mayRaise=[ExceptionFailure]-| | | | <ok>-| | | | | join <hidden>-| | | | |   minReads=(Right 0)-| | | | |   mayRaise=[ExceptionFailure]-| | | | | | commit ExceptionFailure-| | | | | |   minReads=(Right 0)-| | | | | |   mayRaise=[]-| | | | | | refJoin <hidden>-| | | | | |   minReads=(Right 0)-| | | | | |   mayRaise=[]-| | | | | catch ExceptionFailure-| | | | |   minReads=(Right 2)-| | | | |   mayRaise=[ExceptionFailure]-| | | | | | <ok>-| | | | | | | join <hidden>-| | | | | | |   minReads=(Right 0)-| | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | commit ExceptionFailure-| | | | | | | |   minReads=(Right 0)-| | | | | | | |   mayRaise=[]-| | | | | | | | refJoin <hidden>-| | | | | | | |   minReads=(Right 0)-| | | | | | | |   mayRaise=[]-| | | | | | | catch ExceptionFailure-| | | | | | |   minReads=(Right 2)-| | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | <ok>-| | | | | | | | | pushValue (\x_0 -> \x_1 -> x_0)-| | | | | | | | |   minReads=(Right 2)-| | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | | pushValue (\x_0 -> x_0)-| | | | | | | | |   minReads=(Right 2)-| | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | | | | | |   minReads=(Right 2)-| | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | | catch ExceptionFailure-| | | | | | | | |   minReads=(Right 2)-| | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | | | <ok>-| | | | | | | | | | | pushValue (GHC.Types.:)-| | | | | | | | | | |   minReads=(Right 2)-| | | | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | | | | pushValue (\x_0 -> \x_1 -> x_0)-| | | | | | | | | | |   minReads=(Right 2)-| | | | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | | | | pushValue 'i'-| | | | | | | | | | |   minReads=(Right 2)-| | | | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | | | | | | | |   minReads=(Right 2)-| | | | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | | | | read ((GHC.Classes.==) 'i')-| | | | | | | | | | |   minReads=(Right 2)-| | | | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | | | | | | | |   minReads=(Right 1)-| | | | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | | | | | | | |   minReads=(Right 1)-| | | | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | | | | pushValue (GHC.Types.:)-| | | | | | | | | | |   minReads=(Right 1)-| | | | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | | | | pushValue (\x_0 -> \x_1 -> x_0)-| | | | | | | | | | |   minReads=(Right 1)-| | | | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | | | | pushValue 'f'-| | | | | | | | | | |   minReads=(Right 1)-| | | | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | | | | | | | |   minReads=(Right 1)-| | | | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | | | | read ((GHC.Classes.==) 'f')-| | | | | | | | | | |   minReads=(Right 1)-| | | | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | | | | | | | |   minReads=(Right 0)-| | | | | | | | | | |   mayRaise=[]-| | | | | | | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | | | | | | | |   minReads=(Right 0)-| | | | | | | | | | |   mayRaise=[]-| | | | | | | | | | | pushValue GHC.Types.[]-| | | | | | | | | | |   minReads=(Right 0)-| | | | | | | | | | |   mayRaise=[]-| | | | | | | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | | | | | | | |   minReads=(Right 0)-| | | | | | | | | | |   mayRaise=[]-| | | | | | | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | | | | | | | |   minReads=(Right 0)-| | | | | | | | | | |   mayRaise=[]-| | | | | | | | | | | commit ExceptionFailure-| | | | | | | | | | |   minReads=(Right 0)-| | | | | | | | | | |   mayRaise=[]-| | | | | | | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | | | | | | | |   minReads=(Right 0)-| | | | | | | | | | |   mayRaise=[]-| | | | | | | | | | | call <hidden>-| | | | | | | | | | |   minReads=(Right 0)-| | | | | | | | | | |   mayRaise=[]-| | | | | | | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | | | | | | | |   minReads=(Right 0)-| | | | | | | | | | |   mayRaise=[]-| | | | | | | | | | | commit ExceptionFailure-| | | | | | | | | | |   minReads=(Right 0)-| | | | | | | | | | |   mayRaise=[]-| | | | | | | | | | | refJoin <hidden>-| | | | | | | | | | |   minReads=(Right 0)-| | | | | | | | | | |   mayRaise=[]-| | | | | | | | | | <ko>-| | | | | | | | | | | loadInput-| | | | | | | | | | |   minReads=(Left ExceptionFailure)-| | | | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | | | | fail []-| | | | | | | | | | |   minReads=(Left ExceptionFailure)-| | | | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | <ko>-| | | | | | | | | pushInput-| | | | | | | | |   minReads=(Right 11)-| | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | | lift2Value (\(Data.Text.Internal.Text _ i_0 _) (Data.Text.Internal.Text _-| | | | | | | | |                                                                j_1-| | | | | | | | |                                                                _) -> i_0 GHC.Classes.== j_1)-| | | | | | | | |   minReads=(Right 11)-| | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | | choicesBranch [\x_0 -> x_0]-| | | | | | | | |   minReads=(Right 11)-| | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | | | <branch>-| | | | | | | | | | | pushValue (\x_0 -> \x_1 -> x_0)-| | | | | | | | | | |   minReads=(Right 11)-| | | | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | | | | pushValue (\x_0 -> x_0)-| | | | | | | | | | |   minReads=(Right 11)-| | | | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | | | | | | | |   minReads=(Right 11)-| | | | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | | | | pushValue (\x_0 -> \x_1 -> x_0)-| | | | | | | | | | |   minReads=(Right 11)-| | | | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | | | | pushValue (\x_0 -> x_0)-| | | | | | | | | | |   minReads=(Right 11)-| | | | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | | | | | | | |   minReads=(Right 11)-| | | | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | | | | pushValue (\x_0 -> \x_1 -> x_0)-| | | | | | | | | | |   minReads=(Right 11)-| | | | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | | | | pushValue (\x_0 -> x_0)-| | | | | | | | | | |   minReads=(Right 11)-| | | | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | | | | | | | |   minReads=(Right 11)-| | | | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | | | | catch ExceptionFailure-| | | | | | | | | | |   minReads=(Right 11)-| | | | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | | | | | <ok>-| | | | | | | | | | | | | pushValue (GHC.Types.:)-| | | | | | | | | | | | |   minReads=(Right 11)-| | | | | | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | | | | | | pushValue (\x_0 -> \x_1 -> x_0)-| | | | | | | | | | | | |   minReads=(Right 11)-| | | | | | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | | | | | | pushValue 'w'-| | | | | | | | | | | | |   minReads=(Right 11)-| | | | | | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | | | | | | | | | |   minReads=(Right 11)-| | | | | | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | | | | | | read ((GHC.Classes.==) 'w')-| | | | | | | | | | | | |   minReads=(Right 11)-| | | | | | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | | | | | | | | | |   minReads=(Right 10)-| | | | | | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | | | | | | | | | |   minReads=(Right 10)-| | | | | | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | | | | | | pushValue (GHC.Types.:)-| | | | | | | | | | | | |   minReads=(Right 10)-| | | | | | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | | | | | | pushValue (\x_0 -> \x_1 -> x_0)-| | | | | | | | | | | | |   minReads=(Right 10)-| | | | | | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | | | | | | pushValue 'h'-| | | | | | | | | | | | |   minReads=(Right 10)-| | | | | | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | | | | | | | | | |   minReads=(Right 10)-| | | | | | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | | | | | | read ((GHC.Classes.==) 'h')-| | | | | | | | | | | | |   minReads=(Right 10)-| | | | | | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | | | | | | | | | |   minReads=(Right 9)-| | | | | | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | | | | | | | | | |   minReads=(Right 9)-| | | | | | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | | | | | | pushValue (GHC.Types.:)-| | | | | | | | | | | | |   minReads=(Right 9)-| | | | | | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | | | | | | pushValue (\x_0 -> \x_1 -> x_0)-| | | | | | | | | | | | |   minReads=(Right 9)-| | | | | | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | | | | | | pushValue 'i'-| | | | | | | | | | | | |   minReads=(Right 9)-| | | | | | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | | | | | | | | | |   minReads=(Right 9)-| | | | | | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | | | | | | read ((GHC.Classes.==) 'i')-| | | | | | | | | | | | |   minReads=(Right 9)-| | | | | | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | | | | | | | | | |   minReads=(Right 8)-| | | | | | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | | | | | | | | | |   minReads=(Right 8)-| | | | | | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | | | | | | pushValue (GHC.Types.:)-| | | | | | | | | | | | |   minReads=(Right 8)-| | | | | | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | | | | | | pushValue (\x_0 -> \x_1 -> x_0)-| | | | | | | | | | | | |   minReads=(Right 8)-| | | | | | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | | | | | | pushValue 'l'-| | | | | | | | | | | | |   minReads=(Right 8)-| | | | | | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | | | | | | | | | |   minReads=(Right 8)-| | | | | | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | | | | | | read ((GHC.Classes.==) 'l')-| | | | | | | | | | | | |   minReads=(Right 8)-| | | | | | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | | | | | | | | | |   minReads=(Right 7)-| | | | | | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | | | | | | | | | |   minReads=(Right 7)-| | | | | | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | | | | | | pushValue (GHC.Types.:)-| | | | | | | | | | | | |   minReads=(Right 7)-| | | | | | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | | | | | | pushValue (\x_0 -> \x_1 -> x_0)-| | | | | | | | | | | | |   minReads=(Right 7)-| | | | | | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | | | | | | pushValue 'e'-| | | | | | | | | | | | |   minReads=(Right 7)-| | | | | | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | | | | | | | | | |   minReads=(Right 7)-| | | | | | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | | | | | | read ((GHC.Classes.==) 'e')-| | | | | | | | | | | | |   minReads=(Right 7)-| | | | | | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | | | | | | | | | |   minReads=(Right 6)-| | | | | | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | | | | | | | | | |   minReads=(Right 6)-| | | | | | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | | | | | | pushValue GHC.Types.[]-| | | | | | | | | | | | |   minReads=(Right 6)-| | | | | | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | | | | | | | | | |   minReads=(Right 6)-| | | | | | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | | | | | | | | | |   minReads=(Right 6)-| | | | | | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | | | | | | | | | |   minReads=(Right 6)-| | | | | | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | | | | | | | | | |   minReads=(Right 6)-| | | | | | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | | | | | | | | | |   minReads=(Right 6)-| | | | | | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | | | | | | commit ExceptionFailure-| | | | | | | | | | | | |   minReads=(Right 6)-| | | | | | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | | | | | | | | | |   minReads=(Right 6)-| | | | | | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | | | | | | call <hidden>-| | | | | | | | | | | | |   minReads=(Right 6)-| | | | | | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | | | | | | | | | |   minReads=(Right 6)-| | | | | | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | | | | | | | | | |   minReads=(Right 6)-| | | | | | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | | | | | | call <hidden>-| | | | | | | | | | | | |   minReads=(Right 6)-| | | | | | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | | | | | | | | | |   minReads=(Right 4)-| | | | | | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | | | | | | | | | |   minReads=(Right 4)-| | | | | | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | | | | | | call <hidden>-| | | | | | | | | | | | |   minReads=(Right 4)-| | | | | | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | | | | | | | | | |   minReads=(Right 0)-| | | | | | | | | | | | |   mayRaise=[]-| | | | | | | | | | | | | refJoin <hidden>-| | | | | | | | | | | | |   minReads=(Right 0)-| | | | | | | | | | | | |   mayRaise=[]-| | | | | | | | | | | | <ko>-| | | | | | | | | | | | | loadInput-| | | | | | | | | | | | |   minReads=(Left ExceptionFailure)-| | | | | | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | | | | | | fail []-| | | | | | | | | | | | |   minReads=(Left ExceptionFailure)-| | | | | | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | | | <default>-| | | | | | | | | | | fail []-| | | | | | | | | | |   minReads=(Left ExceptionFailure)-| | | | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | <ko>-| | | | | | | pushInput-| | | | | | |   minReads=(Right 8)-| | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | lift2Value (\(Data.Text.Internal.Text _ i_0 _) (Data.Text.Internal.Text _-| | | | | | |                                                                j_1-| | | | | | |                                                                _) -> i_0 GHC.Classes.== j_1)-| | | | | | |   minReads=(Right 8)-| | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | choicesBranch [\x_0 -> x_0]-| | | | | | |   minReads=(Right 8)-| | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | <branch>-| | | | | | | | | catch ExceptionFailure-| | | | | | | | |   minReads=(Right 8)-| | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | | | <ok>-| | | | | | | | | | | pushValue (\x_0 -> \x_1 -> x_0)-| | | | | | | | | | |   minReads=(Right 8)-| | | | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | | | | pushValue (\x_0 -> \x_1 -> x_0)-| | | | | | | | | | |   minReads=(Right 8)-| | | | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | | | | pushValue (\x_0 -> x_0)-| | | | | | | | | | |   minReads=(Right 8)-| | | | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | | | | | | | |   minReads=(Right 8)-| | | | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | | | | pushValue (\x_0 -> \x_1 -> x_0)-| | | | | | | | | | |   minReads=(Right 8)-| | | | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | | | | pushValue (\x_0 -> x_0)-| | | | | | | | | | |   minReads=(Right 8)-| | | | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | | | | | | | |   minReads=(Right 8)-| | | | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | | | | pushValue (\x_0 -> \x_1 -> x_0)-| | | | | | | | | | |   minReads=(Right 8)-| | | | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | | | | pushValue (\x_0 -> x_0)-| | | | | | | | | | |   minReads=(Right 8)-| | | | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | | | | | | | |   minReads=(Right 8)-| | | | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | | | | join <hidden>-| | | | | | | | | | |   minReads=(Right 8)-| | | | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | | | | | | | | |   minReads=(Right 8)-| | | | | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | | | | | pushValue (\x_0 -> \x_1 -> x_0)-| | | | | | | | | | | |   minReads=(Right 8)-| | | | | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | | | | | pushValue (\x_0 -> x_0)-| | | | | | | | | | | |   minReads=(Right 8)-| | | | | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | | | | | | | | |   minReads=(Right 8)-| | | | | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | | | | | call <hidden>-| | | | | | | | | | | |   minReads=(Right 8)-| | | | | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | | | | | | | | |   minReads=(Right 6)-| | | | | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | | | | | pushValue (\x_0 -> \x_1 -> x_0)-| | | | | | | | | | | |   minReads=(Right 6)-| | | | | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | | | | | pushValue (\x_0 -> x_0)-| | | | | | | | | | | |   minReads=(Right 6)-| | | | | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | | | | | | | | |   minReads=(Right 6)-| | | | | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | | | | | pushValue ((\x_0 -> \x_1 -> \x_2 -> x_0 x_2 x_1) (\x_3 -> \x_4 -> x_3 x_4))-| | | | | | | | | | | |   minReads=(Right 6)-| | | | | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | | | | | call <hidden>-| | | | | | | | | | | |   minReads=(Right 6)-| | | | | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | | | | | | | | |   minReads=(Right 0)-| | | | | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | | | | | call <hidden>-| | | | | | | | | | | |   minReads=(Right 0)-| | | | | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | | | | | | | | |   minReads=(Right 0)-| | | | | | | | | | | |   mayRaise=[]-| | | | | | | | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | | | | | | | | |   minReads=(Right 0)-| | | | | | | | | | | |   mayRaise=[]-| | | | | | | | | | | | call <hidden>-| | | | | | | | | | | |   minReads=(Right 0)-| | | | | | | | | | | |   mayRaise=[]-| | | | | | | | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | | | | | | | | |   minReads=(Right 4)-| | | | | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | | | | | | | | |   minReads=(Right 4)-| | | | | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | | | | | | | | |   minReads=(Right 4)-| | | | | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | | | | | | | | |   minReads=(Right 4)-| | | | | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | | | | | pushValue (\x_0 -> \x_1 -> x_0)-| | | | | | | | | | | |   minReads=(Right 4)-| | | | | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | | | | | pushValue (\x_0 -> \x_1 -> x_0)-| | | | | | | | | | | |   minReads=(Right 4)-| | | | | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | | | | | pushValue '='-| | | | | | | | | | | |   minReads=(Right 4)-| | | | | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | | | | | | | | |   minReads=(Right 4)-| | | | | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | | | | | read ((GHC.Classes.==) '=')-| | | | | | | | | | | |   minReads=(Right 4)-| | | | | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | | | | | | | | |   minReads=(Right 3)-| | | | | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | | | | | | | | |   minReads=(Right 3)-| | | | | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | | | | | call <hidden>-| | | | | | | | | | | |   minReads=(Right 3)-| | | | | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | | | | | | | | |   minReads=(Right 2)-| | | | | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | | | | | | | | |   minReads=(Right 2)-| | | | | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | | | | | | | | |   minReads=(Right 2)-| | | | | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | | | | | pushValue (\x_0 -> \x_1 -> x_0)-| | | | | | | | | | | |   minReads=(Right 2)-| | | | | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | | | | | pushValue (\x_0 -> x_0)-| | | | | | | | | | | |   minReads=(Right 2)-| | | | | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | | | | | | | | |   minReads=(Right 2)-| | | | | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | | | | | call <hidden>-| | | | | | | | | | | |   minReads=(Right 2)-| | | | | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | | | | | | | | |   minReads=(Right 0)-| | | | | | | | | | | |   mayRaise=[]-| | | | | | | | | | | | pushValue (\x_0 -> \x_1 -> x_0)-| | | | | | | | | | | |   minReads=(Right 0)-| | | | | | | | | | | |   mayRaise=[]-| | | | | | | | | | | | pushValue (\x_0 -> x_0)-| | | | | | | | | | | |   minReads=(Right 0)-| | | | | | | | | | | |   mayRaise=[]-| | | | | | | | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | | | | | | | | |   minReads=(Right 0)-| | | | | | | | | | | |   mayRaise=[]-| | | | | | | | | | | | pushValue ((\x_0 -> \x_1 -> \x_2 -> x_0 x_2 x_1) (\x_3 -> \x_4 -> x_3 x_4))-| | | | | | | | | | | |   minReads=(Right 0)-| | | | | | | | | | | |   mayRaise=[]-| | | | | | | | | | | | call <hidden>-| | | | | | | | | | | |   minReads=(Right 0)-| | | | | | | | | | | |   mayRaise=[]-| | | | | | | | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | | | | | | | | |   minReads=(Right 0)-| | | | | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | | | | | call <hidden>-| | | | | | | | | | | |   minReads=(Right 0)-| | | | | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | | | | | | | | |   minReads=(Right 0)-| | | | | | | | | | | |   mayRaise=[]-| | | | | | | | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | | | | | | | | |   minReads=(Right 0)-| | | | | | | | | | | |   mayRaise=[]-| | | | | | | | | | | | call <hidden>-| | | | | | | | | | | |   minReads=(Right 0)-| | | | | | | | | | | |   mayRaise=[]-| | | | | | | | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | | | | | | | | |   minReads=(Right 2)-| | | | | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | | | | | | | | |   minReads=(Right 2)-| | | | | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | | | | | | | | |   minReads=(Right 2)-| | | | | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | | | | | | | | |   minReads=(Right 2)-| | | | | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | | | | | call <hidden>-| | | | | | | | | | | |   minReads=(Right 2)-| | | | | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | | | | | | | | |   minReads=(Right 0)-| | | | | | | | | | | |   mayRaise=[]-| | | | | | | | | | | | commit ExceptionFailure-| | | | | | | | | | | |   minReads=(Right 0)-| | | | | | | | | | | |   mayRaise=[]-| | | | | | | | | | | | refJoin <hidden>-| | | | | | | | | | | |   minReads=(Right 0)-| | | | | | | | | | | |   mayRaise=[]-| | | | | | | | | | | catch ExceptionFailure-| | | | | | | | | | |   minReads=(Right 0)-| | | | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | | | | | <ok>-| | | | | | | | | | | | | pushValue (\x_0 -> \x_1 -> x_0)-| | | | | | | | | | | | |   minReads=(Right 3)-| | | | | | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | | | | | | pushValue GHC.Tuple.()-| | | | | | | | | | | | |   minReads=(Right 3)-| | | | | | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | | | | | | | | | |   minReads=(Right 3)-| | | | | | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | | | | | | pushValue (\x_0 -> \x_1 -> x_0)-| | | | | | | | | | | | |   minReads=(Right 3)-| | | | | | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | | | | | | pushValue (\x_0 -> x_0)-| | | | | | | | | | | | |   minReads=(Right 3)-| | | | | | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | | | | | | | | | |   minReads=(Right 3)-| | | | | | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | | | | | | catch ExceptionFailure-| | | | | | | | | | | | |   minReads=(Right 3)-| | | | | | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | | | | | | | <ok>-| | | | | | | | | | | | | | | pushValue (GHC.Types.:)-| | | | | | | | | | | | | | |   minReads=(Right 3)-| | | | | | | | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | | | | | | | | pushValue (\x_0 -> \x_1 -> x_0)-| | | | | | | | | | | | | | |   minReads=(Right 3)-| | | | | | | | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | | | | | | | | pushValue 'v'-| | | | | | | | | | | | | | |   minReads=(Right 3)-| | | | | | | | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | | | | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | | | | | | | | | | | |   minReads=(Right 3)-| | | | | | | | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | | | | | | | | read ((GHC.Classes.==) 'v')-| | | | | | | | | | | | | | |   minReads=(Right 3)-| | | | | | | | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | | | | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | | | | | | | | | | | |   minReads=(Right 2)-| | | | | | | | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | | | | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | | | | | | | | | | | |   minReads=(Right 2)-| | | | | | | | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | | | | | | | | pushValue (GHC.Types.:)-| | | | | | | | | | | | | | |   minReads=(Right 2)-| | | | | | | | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | | | | | | | | pushValue (\x_0 -> \x_1 -> x_0)-| | | | | | | | | | | | | | |   minReads=(Right 2)-| | | | | | | | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | | | | | | | | pushValue 'a'-| | | | | | | | | | | | | | |   minReads=(Right 2)-| | | | | | | | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | | | | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | | | | | | | | | | | |   minReads=(Right 2)-| | | | | | | | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | | | | | | | | read ((GHC.Classes.==) 'a')-| | | | | | | | | | | | | | |   minReads=(Right 2)-| | | | | | | | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | | | | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | | | | | | | | | | | |   minReads=(Right 1)-| | | | | | | | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | | | | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | | | | | | | | | | | |   minReads=(Right 1)-| | | | | | | | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | | | | | | | | pushValue (GHC.Types.:)-| | | | | | | | | | | | | | |   minReads=(Right 1)-| | | | | | | | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | | | | | | | | pushValue (\x_0 -> \x_1 -> x_0)-| | | | | | | | | | | | | | |   minReads=(Right 1)-| | | | | | | | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | | | | | | | | pushValue 'r'-| | | | | | | | | | | | | | |   minReads=(Right 1)-| | | | | | | | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | | | | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | | | | | | | | | | | |   minReads=(Right 1)-| | | | | | | | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | | | | | | | | read ((GHC.Classes.==) 'r')-| | | | | | | | | | | | | | |   minReads=(Right 1)-| | | | | | | | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | | | | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | | | | | | | | | | | |   minReads=(Right 0)-| | | | | | | | | | | | | | |   mayRaise=[]-| | | | | | | | | | | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | | | | | | | | | | | |   minReads=(Right 0)-| | | | | | | | | | | | | | |   mayRaise=[]-| | | | | | | | | | | | | | | pushValue GHC.Types.[]-| | | | | | | | | | | | | | |   minReads=(Right 0)-| | | | | | | | | | | | | | |   mayRaise=[]-| | | | | | | | | | | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | | | | | | | | | | | |   minReads=(Right 0)-| | | | | | | | | | | | | | |   mayRaise=[]-| | | | | | | | | | | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | | | | | | | | | | | |   minReads=(Right 0)-| | | | | | | | | | | | | | |   mayRaise=[]-| | | | | | | | | | | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | | | | | | | | | | | |   minReads=(Right 0)-| | | | | | | | | | | | | | |   mayRaise=[]-| | | | | | | | | | | | | | | commit ExceptionFailure-| | | | | | | | | | | | | | |   minReads=(Right 0)-| | | | | | | | | | | | | | |   mayRaise=[]-| | | | | | | | | | | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | | | | | | | | | | | |   minReads=(Right 0)-| | | | | | | | | | | | | | |   mayRaise=[]-| | | | | | | | | | | | | | | call <hidden>-| | | | | | | | | | | | | | |   minReads=(Right 0)-| | | | | | | | | | | | | | |   mayRaise=[]-| | | | | | | | | | | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | | | | | | | | | | | |   minReads=(Right 0)-| | | | | | | | | | | | | | |   mayRaise=[]-| | | | | | | | | | | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | | | | | | | | | | | |   minReads=(Right 0)-| | | | | | | | | | | | | | |   mayRaise=[]-| | | | | | | | | | | | | | | commit ExceptionFailure-| | | | | | | | | | | | | | |   minReads=(Right 0)-| | | | | | | | | | | | | | |   mayRaise=[]-| | | | | | | | | | | | | | | refJoin <hidden>-| | | | | | | | | | | | | | |   minReads=(Right 0)-| | | | | | | | | | | | | | |   mayRaise=[]-| | | | | | | | | | | | | | <ko>-| | | | | | | | | | | | | | | loadInput-| | | | | | | | | | | | | | |   minReads=(Left ExceptionFailure)-| | | | | | | | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | | | | | | | | fail []-| | | | | | | | | | | | | | |   minReads=(Left ExceptionFailure)-| | | | | | | | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | | | | | <ko>-| | | | | | | | | | | | | pushInput-| | | | | | | | | | | | |   minReads=(Right 0)-| | | | | | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | | | | | | lift2Value (\(Data.Text.Internal.Text _ i_0 _) (Data.Text.Internal.Text _-| | | | | | | | | | | | |                                                                j_1-| | | | | | | | | | | | |                                                                _) -> i_0 GHC.Classes.== j_1)-| | | | | | | | | | | | |   minReads=(Right 0)-| | | | | | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | | | | | | choicesBranch [\x_0 -> x_0]-| | | | | | | | | | | | |   minReads=(Right 0)-| | | | | | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | | | | | | | <branch>-| | | | | | | | | | | | | | | call <hidden>-| | | | | | | | | | | | | | |   minReads=(Right 0)-| | | | | | | | | | | | | | |   mayRaise=[]-| | | | | | | | | | | | | | | refJoin <hidden>-| | | | | | | | | | | | | | |   minReads=(Right 0)-| | | | | | | | | | | | | | |   mayRaise=[]-| | | | | | | | | | | | | | <default>-| | | | | | | | | | | | | | | fail []-| | | | | | | | | | | | | | |   minReads=(Left ExceptionFailure)-| | | | | | | | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | | | <ko>-| | | | | | | | | | | loadInput-| | | | | | | | | | |   minReads=(Left ExceptionFailure)-| | | | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | | | | fail []-| | | | | | | | | | |   minReads=(Left ExceptionFailure)-| | | | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | <default>-| | | | | | | | | fail []-| | | | | | | | |   minReads=(Left ExceptionFailure)-| | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | <ko>-| | | | | pushInput-| | | | |   minReads=(Right 4)-| | | | |   mayRaise=[ExceptionFailure]-| | | | | lift2Value (\(Data.Text.Internal.Text _ i_0 _) (Data.Text.Internal.Text _-| | | | |                                                                j_1-| | | | |                                                                _) -> i_0 GHC.Classes.== j_1)-| | | | |   minReads=(Right 4)-| | | | |   mayRaise=[ExceptionFailure]-| | | | | choicesBranch [\x_0 -> x_0]-| | | | |   minReads=(Right 4)-| | | | |   mayRaise=[ExceptionFailure]-| | | | | | <branch>-| | | | | | | pushValue (\x_0 -> \x_1 -> x_0)-| | | | | | |   minReads=(Right 4)-| | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | call <hidden>-| | | | | | |   minReads=(Right 4)-| | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | | | |   minReads=(Right 2)-| | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | call <hidden>-| | | | | | |   minReads=(Right 2)-| | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | | | |   minReads=(Right 0)-| | | | | | |   mayRaise=[]-| | | | | | | refJoin <hidden>-| | | | | | |   minReads=(Right 0)-| | | | | | |   mayRaise=[]-| | | | | | <default>-| | | | | | | fail []-| | | | | | |   minReads=(Left ExceptionFailure)-| | | | | | |   mayRaise=[ExceptionFailure]-| | <ko>-| | | pushInput-| | |   minReads=(Right 0)-| | |   mayRaise=[ExceptionFailure]-| | | lift2Value (\(Data.Text.Internal.Text _ i_0 _) (Data.Text.Internal.Text _-| | |                                                                j_1-| | |                                                                _) -> i_0 GHC.Classes.== j_1)-| | |   minReads=(Right 0)-| | |   mayRaise=[ExceptionFailure]-| | | choicesBranch [\x_0 -> x_0]-| | |   minReads=(Right 0)-| | |   mayRaise=[ExceptionFailure]-| | | | <branch>-| | | | | pushValue (\x_0 -> x_0)-| | | | |   minReads=(Right 0)-| | | | |   mayRaise=[]-| | | | | ret-| | | | |   minReads=(Right 0)-| | | | |   mayRaise=[]-| | | | <default>-| | | | | fail []-| | | | |   minReads=(Left ExceptionFailure)-| | | | |   mayRaise=[ExceptionFailure]-let <hidden>-  minReads=(Right 0)-  mayRaise=[ExceptionFailure]-| catch ExceptionFailure-|   minReads=(Right 0)-|   mayRaise=[ExceptionFailure]-| | <ok>-| | | pushValue (\x_0 -> \x_1 -> \x_2 -> x_0 (x_1 x_2))-| | |   minReads=(Right 4)-| | |   mayRaise=[ExceptionFailure]-| | | call <hidden>-| | |   minReads=(Right 4)-| | |   mayRaise=[ExceptionFailure]-| | | pushValue (\x_0 -> \x_1 -> x_0)-| | |   minReads=(Right 4)-| | |   mayRaise=[ExceptionFailure]-| | | pushValue (\x_0 -> x_0)-| | |   minReads=(Right 4)-| | |   mayRaise=[ExceptionFailure]-| | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | |   minReads=(Right 4)-| | |   mayRaise=[ExceptionFailure]-| | | call <hidden>-| | |   minReads=(Right 4)-| | |   mayRaise=[ExceptionFailure]-| | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | |   minReads=(Right 2)-| | |   mayRaise=[ExceptionFailure]-| | | call <hidden>-| | |   minReads=(Right 2)-| | |   mayRaise=[ExceptionFailure]-| | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | |   minReads=(Right 0)-| | |   mayRaise=[ExceptionFailure]-| | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | |   minReads=(Right 0)-| | |   mayRaise=[ExceptionFailure]-| | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | |   minReads=(Right 0)-| | |   mayRaise=[ExceptionFailure]-| | | call <hidden>-| | |   minReads=(Right 0)-| | |   mayRaise=[ExceptionFailure]-| | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | |   minReads=(Right 0)-| | |   mayRaise=[]-| | | commit ExceptionFailure-| | |   minReads=(Right 0)-| | |   mayRaise=[]-| | | ret-| | |   minReads=(Right 0)-| | |   mayRaise=[]-| | <ko>-| | | pushInput-| | |   minReads=(Right 0)-| | |   mayRaise=[ExceptionFailure]-| | | lift2Value (\(Data.Text.Internal.Text _ i_0 _) (Data.Text.Internal.Text _-| | |                                                                j_1-| | |                                                                _) -> i_0 GHC.Classes.== j_1)-| | |   minReads=(Right 0)-| | |   mayRaise=[ExceptionFailure]-| | | choicesBranch [\x_0 -> x_0]-| | |   minReads=(Right 0)-| | |   mayRaise=[ExceptionFailure]-| | | | <branch>-| | | | | pushValue (\x_0 -> x_0)-| | | | |   minReads=(Right 0)-| | | | |   mayRaise=[]-| | | | | ret-| | | | |   minReads=(Right 0)-| | | | |   mayRaise=[]-| | | | <default>-| | | | | fail []-| | | | |   minReads=(Left ExceptionFailure)-| | | | |   mayRaise=[ExceptionFailure]-let <hidden>-  minReads=(Right 0)-  mayRaise=[ExceptionFailure]-| catch ExceptionFailure-|   minReads=(Right 0)-|   mayRaise=[ExceptionFailure]-| | <ok>-| | | pushValue (\x_0 -> \x_1 -> \x_2 -> x_0 (x_1 x_2))-| | |   minReads=(Right 4)-| | |   mayRaise=[ExceptionFailure]-| | | call <hidden>-| | |   minReads=(Right 4)-| | |   mayRaise=[ExceptionFailure]-| | | pushValue (\x_0 -> \x_1 -> x_0)-| | |   minReads=(Right 4)-| | |   mayRaise=[ExceptionFailure]-| | | pushValue (\x_0 -> x_0)-| | |   minReads=(Right 4)-| | |   mayRaise=[ExceptionFailure]-| | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | |   minReads=(Right 4)-| | |   mayRaise=[ExceptionFailure]-| | | call <hidden>-| | |   minReads=(Right 4)-| | |   mayRaise=[ExceptionFailure]-| | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | |   minReads=(Right 2)-| | |   mayRaise=[ExceptionFailure]-| | | call <hidden>-| | |   minReads=(Right 2)-| | |   mayRaise=[ExceptionFailure]-| | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | |   minReads=(Right 0)-| | |   mayRaise=[ExceptionFailure]-| | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | |   minReads=(Right 0)-| | |   mayRaise=[ExceptionFailure]-| | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | |   minReads=(Right 0)-| | |   mayRaise=[ExceptionFailure]-| | | call <hidden>-| | |   minReads=(Right 0)-| | |   mayRaise=[ExceptionFailure]-| | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | |   minReads=(Right 0)-| | |   mayRaise=[]-| | | commit ExceptionFailure-| | |   minReads=(Right 0)-| | |   mayRaise=[]-| | | ret-| | |   minReads=(Right 0)-| | |   mayRaise=[]-| | <ko>-| | | pushInput-| | |   minReads=(Right 0)-| | |   mayRaise=[ExceptionFailure]-| | | lift2Value (\(Data.Text.Internal.Text _ i_0 _) (Data.Text.Internal.Text _-| | |                                                                j_1-| | |                                                                _) -> i_0 GHC.Classes.== j_1)-| | |   minReads=(Right 0)-| | |   mayRaise=[ExceptionFailure]-| | | choicesBranch [\x_0 -> x_0]-| | |   minReads=(Right 0)-| | |   mayRaise=[ExceptionFailure]-| | | | <branch>-| | | | | pushValue (\x_0 -> x_0)-| | | | |   minReads=(Right 0)-| | | | |   mayRaise=[]-| | | | | ret-| | | | |   minReads=(Right 0)-| | | | |   mayRaise=[]-| | | | <default>-| | | | | fail []-| | | | |   minReads=(Left ExceptionFailure)-| | | | |   mayRaise=[ExceptionFailure]-let <hidden>-  minReads=(Right 0)-  mayRaise=[ExceptionFailure]-| catch ExceptionFailure-|   minReads=(Right 0)-|   mayRaise=[ExceptionFailure]-| | <ok>-| | | pushValue (\x_0 -> \x_1 -> \x_2 -> x_0 (x_1 x_2))-| | |   minReads=(Right 4)-| | |   mayRaise=[ExceptionFailure]-| | | call <hidden>-| | |   minReads=(Right 4)-| | |   mayRaise=[ExceptionFailure]-| | | pushValue (\x_0 -> \x_1 -> x_0)-| | |   minReads=(Right 4)-| | |   mayRaise=[ExceptionFailure]-| | | pushValue (\x_0 -> x_0)-| | |   minReads=(Right 4)-| | |   mayRaise=[ExceptionFailure]-| | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | |   minReads=(Right 4)-| | |   mayRaise=[ExceptionFailure]-| | | call <hidden>-| | |   minReads=(Right 4)-| | |   mayRaise=[ExceptionFailure]-| | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | |   minReads=(Right 2)-| | |   mayRaise=[ExceptionFailure]-| | | call <hidden>-| | |   minReads=(Right 2)-| | |   mayRaise=[ExceptionFailure]-| | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | |   minReads=(Right 0)-| | |   mayRaise=[ExceptionFailure]-| | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | |   minReads=(Right 0)-| | |   mayRaise=[ExceptionFailure]-| | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | |   minReads=(Right 0)-| | |   mayRaise=[ExceptionFailure]-| | | call <hidden>-| | |   minReads=(Right 0)-| | |   mayRaise=[ExceptionFailure]-| | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | |   minReads=(Right 0)-| | |   mayRaise=[]-| | | commit ExceptionFailure-| | |   minReads=(Right 0)-| | |   mayRaise=[]-| | | ret-| | |   minReads=(Right 0)-| | |   mayRaise=[]-| | <ko>-| | | pushInput-| | |   minReads=(Right 0)-| | |   mayRaise=[ExceptionFailure]-| | | lift2Value (\(Data.Text.Internal.Text _ i_0 _) (Data.Text.Internal.Text _-| | |                                                                j_1-| | |                                                                _) -> i_0 GHC.Classes.== j_1)-| | |   minReads=(Right 0)-| | |   mayRaise=[ExceptionFailure]-| | | choicesBranch [\x_0 -> x_0]-| | |   minReads=(Right 0)-| | |   mayRaise=[ExceptionFailure]-| | | | <branch>-| | | | | pushValue (\x_0 -> x_0)-| | | | |   minReads=(Right 0)-| | | | |   mayRaise=[]-| | | | | ret-| | | | |   minReads=(Right 0)-| | | | |   mayRaise=[]-| | | | <default>-| | | | | fail []-| | | | |   minReads=(Left ExceptionFailure)-| | | | |   mayRaise=[ExceptionFailure]-let <hidden>-  minReads=(Right 0)-  mayRaise=[ExceptionFailure]-| catch ExceptionFailure-|   minReads=(Right 0)-|   mayRaise=[ExceptionFailure]-| | <ok>-| | | pushValue (\x_0 -> \x_1 -> \x_2 -> x_0 (x_1 x_2))-| | |   minReads=(Right 4)-| | |   mayRaise=[ExceptionFailure]-| | | call <hidden>-| | |   minReads=(Right 4)-| | |   mayRaise=[ExceptionFailure]-| | | pushValue (\x_0 -> \x_1 -> x_0)-| | |   minReads=(Right 4)-| | |   mayRaise=[ExceptionFailure]-| | | pushValue (\x_0 -> x_0)-| | |   minReads=(Right 4)-| | |   mayRaise=[ExceptionFailure]-| | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | |   minReads=(Right 4)-| | |   mayRaise=[ExceptionFailure]-| | | call <hidden>-| | |   minReads=(Right 4)-| | |   mayRaise=[ExceptionFailure]-| | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | |   minReads=(Right 2)-| | |   mayRaise=[ExceptionFailure]-| | | call <hidden>-| | |   minReads=(Right 2)-| | |   mayRaise=[ExceptionFailure]-| | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | |   minReads=(Right 0)-| | |   mayRaise=[ExceptionFailure]-| | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | |   minReads=(Right 0)-| | |   mayRaise=[ExceptionFailure]-| | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | |   minReads=(Right 0)-| | |   mayRaise=[ExceptionFailure]-| | | call <hidden>-| | |   minReads=(Right 0)-| | |   mayRaise=[ExceptionFailure]-| | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | |   minReads=(Right 0)-| | |   mayRaise=[]-| | | commit ExceptionFailure-| | |   minReads=(Right 0)-| | |   mayRaise=[]-| | | ret-| | |   minReads=(Right 0)-| | |   mayRaise=[]-| | <ko>-| | | pushInput-| | |   minReads=(Right 0)-| | |   mayRaise=[ExceptionFailure]-| | | lift2Value (\(Data.Text.Internal.Text _ i_0 _) (Data.Text.Internal.Text _-| | |                                                                j_1-| | |                                                                _) -> i_0 GHC.Classes.== j_1)-| | |   minReads=(Right 0)-| | |   mayRaise=[ExceptionFailure]-| | | choicesBranch [\x_0 -> x_0]-| | |   minReads=(Right 0)-| | |   mayRaise=[ExceptionFailure]-| | | | <branch>-| | | | | pushValue (\x_0 -> x_0)-| | | | |   minReads=(Right 0)-| | | | |   mayRaise=[]-| | | | | ret-| | | | |   minReads=(Right 0)-| | | | |   mayRaise=[]-| | | | <default>-| | | | | fail []-| | | | |   minReads=(Left ExceptionFailure)-| | | | |   mayRaise=[ExceptionFailure]-let <hidden>-  minReads=(Right 0)-  mayRaise=[ExceptionFailure]-| catch ExceptionFailure-|   minReads=(Right 0)-|   mayRaise=[ExceptionFailure]-| | <ok>-| | | pushValue (\x_0 -> \x_1 -> \x_2 -> x_0 (x_1 x_2))-| | |   minReads=(Right 4)-| | |   mayRaise=[ExceptionFailure]-| | | pushValue (\x_0 -> \x_1 -> \x_2 -> x_0 x_2 x_1)-| | |   minReads=(Right 4)-| | |   mayRaise=[ExceptionFailure]-| | | pushValue (\x_0 -> \x_1 -> x_0)-| | |   minReads=(Right 4)-| | |   mayRaise=[ExceptionFailure]-| | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | |   minReads=(Right 4)-| | |   mayRaise=[ExceptionFailure]-| | | pushValue (\x_0 -> \x_1 -> x_0)-| | |   minReads=(Right 4)-| | |   mayRaise=[ExceptionFailure]-| | | pushValue (\x_0 -> x_0)-| | |   minReads=(Right 4)-| | |   mayRaise=[ExceptionFailure]-| | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | |   minReads=(Right 4)-| | |   mayRaise=[ExceptionFailure]-| | | pushValue (\x_0 -> \x_1 -> x_0)-| | |   minReads=(Right 4)-| | |   mayRaise=[ExceptionFailure]-| | | pushValue (\x_0 -> \x_1 -> x_0)-| | |   minReads=(Right 4)-| | |   mayRaise=[ExceptionFailure]-| | | pushValue '!'-| | |   minReads=(Right 4)-| | |   mayRaise=[ExceptionFailure]-| | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | |   minReads=(Right 4)-| | |   mayRaise=[ExceptionFailure]-| | | read ((GHC.Classes.==) '!')-| | |   minReads=(Right 4)-| | |   mayRaise=[ExceptionFailure]-| | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | |   minReads=(Right 3)-| | |   mayRaise=[ExceptionFailure]-| | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | |   minReads=(Right 3)-| | |   mayRaise=[ExceptionFailure]-| | | call <hidden>-| | |   minReads=(Right 3)-| | |   mayRaise=[ExceptionFailure]-| | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | |   minReads=(Right 2)-| | |   mayRaise=[ExceptionFailure]-| | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | |   minReads=(Right 2)-| | |   mayRaise=[ExceptionFailure]-| | | call <hidden>-| | |   minReads=(Right 2)-| | |   mayRaise=[ExceptionFailure]-| | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | |   minReads=(Right 0)-| | |   mayRaise=[ExceptionFailure]-| | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | |   minReads=(Right 0)-| | |   mayRaise=[ExceptionFailure]-| | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | |   minReads=(Right 0)-| | |   mayRaise=[ExceptionFailure]-| | | call <hidden>-| | |   minReads=(Right 0)-| | |   mayRaise=[ExceptionFailure]-| | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | |   minReads=(Right 0)-| | |   mayRaise=[]-| | | commit ExceptionFailure-| | |   minReads=(Right 0)-| | |   mayRaise=[]-| | | ret-| | |   minReads=(Right 0)-| | |   mayRaise=[]-| | <ko>-| | | pushInput-| | |   minReads=(Right 0)-| | |   mayRaise=[ExceptionFailure]-| | | lift2Value (\(Data.Text.Internal.Text _ i_0 _) (Data.Text.Internal.Text _-| | |                                                                j_1-| | |                                                                _) -> i_0 GHC.Classes.== j_1)-| | |   minReads=(Right 0)-| | |   mayRaise=[ExceptionFailure]-| | | choicesBranch [\x_0 -> x_0]-| | |   minReads=(Right 0)-| | |   mayRaise=[ExceptionFailure]-| | | | <branch>-| | | | | pushValue (\x_0 -> x_0)-| | | | |   minReads=(Right 0)-| | | | |   mayRaise=[]-| | | | | ret-| | | | |   minReads=(Right 0)-| | | | |   mayRaise=[]-| | | | <default>-| | | | | fail []-| | | | |   minReads=(Left ExceptionFailure)-| | | | |   mayRaise=[ExceptionFailure]-let <hidden>-  minReads=(Right 0)-  mayRaise=[ExceptionFailure]-| catch ExceptionFailure-|   minReads=(Right 0)-|   mayRaise=[ExceptionFailure]-| | <ok>-| | | pushValue (\x_0 -> \x_1 -> x_0)-| | |   minReads=(Right 2)-| | |   mayRaise=[ExceptionFailure]-| | | pushValue GHC.Tuple.()-| | |   minReads=(Right 2)-| | |   mayRaise=[ExceptionFailure]-| | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | |   minReads=(Right 2)-| | |   mayRaise=[ExceptionFailure]-| | | pushValue (\x_0 -> \x_1 -> x_0)-| | |   minReads=(Right 2)-| | |   mayRaise=[ExceptionFailure]-| | | pushValue (\x_0 -> x_0)-| | |   minReads=(Right 2)-| | |   mayRaise=[ExceptionFailure]-| | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | |   minReads=(Right 2)-| | |   mayRaise=[ExceptionFailure]-| | | call <hidden>-| | |   minReads=(Right 2)-| | |   mayRaise=[ExceptionFailure]-| | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | |   minReads=(Right 0)-| | |   mayRaise=[ExceptionFailure]-| | | pushValue (\x_0 -> \x_1 -> x_0)-| | |   minReads=(Right 0)-| | |   mayRaise=[ExceptionFailure]-| | | pushValue (\x_0 -> x_0)-| | |   minReads=(Right 0)-| | |   mayRaise=[ExceptionFailure]-| | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | |   minReads=(Right 0)-| | |   mayRaise=[ExceptionFailure]-| | | pushValue ((\x_0 -> \x_1 -> \x_2 -> x_0 x_2 x_1) (\x_3 -> \x_4 -> x_3 x_4))-| | |   minReads=(Right 0)-| | |   mayRaise=[ExceptionFailure]-| | | call <hidden>-| | |   minReads=(Right 0)-| | |   mayRaise=[ExceptionFailure]-| | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | |   minReads=(Right 0)-| | |   mayRaise=[ExceptionFailure]-| | | call <hidden>-| | |   minReads=(Right 0)-| | |   mayRaise=[ExceptionFailure]-| | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | |   minReads=(Right 0)-| | |   mayRaise=[]-| | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | |   minReads=(Right 0)-| | |   mayRaise=[]-| | | call <hidden>-| | |   minReads=(Right 0)-| | |   mayRaise=[]-| | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | |   minReads=(Right 0)-| | |   mayRaise=[]-| | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | |   minReads=(Right 0)-| | |   mayRaise=[]-| | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | |   minReads=(Right 0)-| | |   mayRaise=[]-| | | commit ExceptionFailure-| | |   minReads=(Right 0)-| | |   mayRaise=[]-| | | ret-| | |   minReads=(Right 0)-| | |   mayRaise=[]-| | <ko>-| | | pushInput-| | |   minReads=(Right 0)-| | |   mayRaise=[ExceptionFailure]-| | | lift2Value (\(Data.Text.Internal.Text _ i_0 _) (Data.Text.Internal.Text _-| | |                                                                j_1-| | |                                                                _) -> i_0 GHC.Classes.== j_1)-| | |   minReads=(Right 0)-| | |   mayRaise=[ExceptionFailure]-| | | choicesBranch [\x_0 -> x_0]-| | |   minReads=(Right 0)-| | |   mayRaise=[ExceptionFailure]-| | | | <branch>-| | | | | jump <hidden>-| | | | |   minReads=(Right 0)-| | | | |   mayRaise=[]-| | | | <default>-| | | | | fail []-| | | | |   minReads=(Left ExceptionFailure)-| | | | |   mayRaise=[ExceptionFailure]-let <hidden>-  minReads=(Right 0)-  mayRaise=[]-| pushValue (\x_0 -> \x_1 -> \x_2 -> x_0 x_2 x_1)-|   minReads=(Right 0)-|   mayRaise=[]-| pushValue (\x_0 -> \x_1 -> x_0)-|   minReads=(Right 0)-|   mayRaise=[]-| lift2Value (\x_0 -> \x_1 -> x_0 x_1)-|   minReads=(Right 0)-|   mayRaise=[]-| ret-|   minReads=(Right 0)-|   mayRaise=[]-let <hidden>-  minReads=(Right 0)-  mayRaise=[]-| pushValue GHC.Tuple.()-|   minReads=(Right 0)-|   mayRaise=[]-| ret-|   minReads=(Right 0)-|   mayRaise=[]-let <hidden>-  minReads=(Right 0)-  mayRaise=[]-| pushValue GHC.Tuple.()-|   minReads=(Right 0)-|   mayRaise=[]-| ret-|   minReads=(Right 0)-|   mayRaise=[]-let <hidden>-  minReads=(Right 1)-  mayRaise=[ExceptionFailure]-| pushValue (\x_0 -> \x_1 -> x_0)-|   minReads=(Right 1)-|   mayRaise=[ExceptionFailure]-| pushValue (\x_0 -> x_0)-|   minReads=(Right 1)-|   mayRaise=[ExceptionFailure]-| lift2Value (\x_0 -> \x_1 -> x_0 x_1)-|   minReads=(Right 1)-|   mayRaise=[ExceptionFailure]-| call <hidden>-|   minReads=(Right 1)-|   mayRaise=[ExceptionFailure]-| lift2Value (\x_0 -> \x_1 -> x_0 x_1)-|   minReads=(Right 0)-|   mayRaise=[ExceptionFailure]-| pushValue (\x_0 -> \x_1 -> x_0)-|   minReads=(Right 0)-|   mayRaise=[ExceptionFailure]-| pushValue (\x_0 -> x_0)-|   minReads=(Right 0)-|   mayRaise=[ExceptionFailure]-| lift2Value (\x_0 -> \x_1 -> x_0 x_1)-|   minReads=(Right 0)-|   mayRaise=[ExceptionFailure]-| pushValue ((\x_0 -> \x_1 -> \x_2 -> x_0 x_2 x_1) (\x_3 -> \x_4 -> x_3 x_4))-|   minReads=(Right 0)-|   mayRaise=[ExceptionFailure]-| pushValue GHC.Tuple.()-|   minReads=(Right 0)-|   mayRaise=[ExceptionFailure]-| lift2Value (\x_0 -> \x_1 -> x_0 x_1)-|   minReads=(Right 0)-|   mayRaise=[ExceptionFailure]-| call <hidden>-|   minReads=(Right 0)-|   mayRaise=[ExceptionFailure]-| lift2Value (\x_0 -> \x_1 -> x_0 x_1)-|   minReads=(Right 0)-|   mayRaise=[]-| lift2Value (\x_0 -> \x_1 -> x_0 x_1)-|   minReads=(Right 0)-|   mayRaise=[]-| pushValue GHC.Tuple.()-|   minReads=(Right 0)-|   mayRaise=[]-| lift2Value (\x_0 -> \x_1 -> x_0 x_1)-|   minReads=(Right 0)-|   mayRaise=[]-| lift2Value (\x_0 -> \x_1 -> x_0 x_1)-|   minReads=(Right 0)-|   mayRaise=[]-| ret-|   minReads=(Right 0)-|   mayRaise=[]-let <hidden>-  minReads=(Right 1)-  mayRaise=[ExceptionFailure]-| pushValue (\x_0 -> \x_1 -> x_0)-|   minReads=(Right 1)-|   mayRaise=[ExceptionFailure]-| pushValue (\x_0 -> x_0)-|   minReads=(Right 1)-|   mayRaise=[ExceptionFailure]-| lift2Value (\x_0 -> \x_1 -> x_0 x_1)-|   minReads=(Right 1)-|   mayRaise=[ExceptionFailure]-| read GHC.Unicode.isSpace-|   minReads=(Right 1)-|   mayRaise=[ExceptionFailure]-| lift2Value (\x_0 -> \x_1 -> x_0 x_1)-|   minReads=(Right 0)-|   mayRaise=[]-| call <hidden>-|   minReads=(Right 0)-|   mayRaise=[]-| lift2Value (\x_0 -> \x_1 -> x_0 x_1)-|   minReads=(Right 0)-|   mayRaise=[]-| ret-|   minReads=(Right 0)-|   mayRaise=[]-let <hidden>-  minReads=(Right 1)-  mayRaise=[ExceptionFailure]-| read (\t_0 -> ('0' GHC.Classes.== t_0) GHC.Classes.|| (('1' GHC.Classes.== t_0) GHC.Classes.|| (('2' GHC.Classes.== t_0) GHC.Classes.|| (('3' GHC.Classes.== t_0) GHC.Classes.|| (('4' GHC.Classes.== t_0) GHC.Classes.|| (('5' GHC.Classes.== t_0) GHC.Classes.|| (('6' GHC.Classes.== t_0) GHC.Classes.|| (('7' GHC.Classes.== t_0) GHC.Classes.|| (('8' GHC.Classes.== t_0) GHC.Classes.|| (('9' GHC.Classes.== t_0) GHC.Classes.|| GHC.Types.False))))))))))-|   minReads=(Right 1)-|   mayRaise=[ExceptionFailure]-| ret-|   minReads=(Right 0)-|   mayRaise=[]-let <hidden>-  minReads=(Right 2)-  mayRaise=[ExceptionFailure]-| catch ExceptionFailure-|   minReads=(Right 2)-|   mayRaise=[ExceptionFailure]-| | <ok>-| | | join <hidden>-| | |   minReads=(Right 0)-| | |   mayRaise=[]-| | | | commit ExceptionFailure-| | | |   minReads=(Right 0)-| | | |   mayRaise=[]-| | | | ret-| | | |   minReads=(Right 0)-| | | |   mayRaise=[]-| | | catch ExceptionFailure-| | |   minReads=(Right 2)-| | |   mayRaise=[ExceptionFailure]-| | | | <ok>-| | | | | pushValue (\x_0 -> \x_1 -> x_0)-| | | | |   minReads=(Right 2)-| | | | |   mayRaise=[ExceptionFailure]-| | | | | pushValue (\x_0 -> x_0)-| | | | |   minReads=(Right 2)-| | | | |   mayRaise=[ExceptionFailure]-| | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | |   minReads=(Right 2)-| | | | |   mayRaise=[ExceptionFailure]-| | | | | join <hidden>-| | | | |   minReads=(Right 1)-| | | | |   mayRaise=[ExceptionFailure]-| | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | | |   minReads=(Right 1)-| | | | | |   mayRaise=[ExceptionFailure]-| | | | | | call <hidden>-| | | | | |   minReads=(Right 1)-| | | | | |   mayRaise=[ExceptionFailure]-| | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | | |   minReads=(Right 0)-| | | | | |   mayRaise=[]-| | | | | | commit ExceptionFailure-| | | | | |   minReads=(Right 0)-| | | | | |   mayRaise=[]-| | | | | | refJoin <hidden>-| | | | | |   minReads=(Right 0)-| | | | | |   mayRaise=[]-| | | | | catch ExceptionFailure-| | | | |   minReads=(Right 1)-| | | | |   mayRaise=[ExceptionFailure]-| | | | | | <ok>-| | | | | | | pushValue (\x_0 -> \x_1 -> x_0)-| | | | | | |   minReads=(Right 1)-| | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | pushValue '0'-| | | | | | |   minReads=(Right 1)-| | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | | | |   minReads=(Right 1)-| | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | read ((GHC.Classes.==) '0')-| | | | | | |   minReads=(Right 1)-| | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | | | |   minReads=(Right 0)-| | | | | | |   mayRaise=[]-| | | | | | | commit ExceptionFailure-| | | | | | |   minReads=(Right 0)-| | | | | | |   mayRaise=[]-| | | | | | | refJoin <hidden>-| | | | | | |   minReads=(Right 0)-| | | | | | |   mayRaise=[]-| | | | | | <ko>-| | | | | | | pushInput-| | | | | | |   minReads=(Right 1)-| | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | lift2Value (\(Data.Text.Internal.Text _ i_0 _) (Data.Text.Internal.Text _-| | | | | | |                                                                j_1-| | | | | | |                                                                _) -> i_0 GHC.Classes.== j_1)-| | | | | | |   minReads=(Right 1)-| | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | choicesBranch [\x_0 -> x_0]-| | | | | | |   minReads=(Right 1)-| | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | <branch>-| | | | | | | | | pushValue (\x_0 -> \x_1 -> x_0)-| | | | | | | | |   minReads=(Right 1)-| | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | | pushValue '1'-| | | | | | | | |   minReads=(Right 1)-| | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | | | | | |   minReads=(Right 1)-| | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | | read ((GHC.Classes.==) '1')-| | | | | | | | |   minReads=(Right 1)-| | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | | | | | |   minReads=(Right 0)-| | | | | | | | |   mayRaise=[]-| | | | | | | | | refJoin <hidden>-| | | | | | | | |   minReads=(Right 0)-| | | | | | | | |   mayRaise=[]-| | | | | | | | <default>-| | | | | | | | | fail []-| | | | | | | | |   minReads=(Left ExceptionFailure)-| | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | <ko>-| | | | | pushInput-| | | | |   minReads=(Right 4)-| | | | |   mayRaise=[ExceptionFailure]-| | | | | lift2Value (\(Data.Text.Internal.Text _ i_0 _) (Data.Text.Internal.Text _-| | | | |                                                                j_1-| | | | |                                                                _) -> i_0 GHC.Classes.== j_1)-| | | | |   minReads=(Right 4)-| | | | |   mayRaise=[ExceptionFailure]-| | | | | choicesBranch [\x_0 -> x_0]-| | | | |   minReads=(Right 4)-| | | | |   mayRaise=[ExceptionFailure]-| | | | | | <branch>-| | | | | | | pushValue (\x_0 -> \x_1 -> x_0)-| | | | | | |   minReads=(Right 4)-| | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | pushValue (\x_0 -> \x_1 -> x_0)-| | | | | | |   minReads=(Right 4)-| | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | pushValue (\x_0 -> x_0)-| | | | | | |   minReads=(Right 4)-| | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | | | |   minReads=(Right 4)-| | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | pushValue (\x_0 -> \x_1 -> x_0)-| | | | | | |   minReads=(Right 4)-| | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | pushValue '\''-| | | | | | |   minReads=(Right 4)-| | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | | | |   minReads=(Right 4)-| | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | read ((GHC.Classes.==) '\'')-| | | | | | |   minReads=(Right 4)-| | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | | | |   minReads=(Right 3)-| | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | | | |   minReads=(Right 3)-| | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | join <hidden>-| | | | | | |   minReads=(Right 2)-| | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | | | | |   minReads=(Right 2)-| | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | | | | |   minReads=(Right 2)-| | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | pushValue (\x_0 -> \x_1 -> x_0)-| | | | | | | |   minReads=(Right 2)-| | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | pushValue (\x_0 -> \x_1 -> x_0)-| | | | | | | |   minReads=(Right 2)-| | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | pushValue '\''-| | | | | | | |   minReads=(Right 2)-| | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | | | | |   minReads=(Right 2)-| | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | read ((GHC.Classes.==) '\'')-| | | | | | | |   minReads=(Right 2)-| | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | | | | |   minReads=(Right 1)-| | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | | | | |   minReads=(Right 1)-| | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | call <hidden>-| | | | | | | |   minReads=(Right 1)-| | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | | | | |   minReads=(Right 0)-| | | | | | | |   mayRaise=[]-| | | | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | | | | |   minReads=(Right 0)-| | | | | | | |   mayRaise=[]-| | | | | | | | refJoin <hidden>-| | | | | | | |   minReads=(Right 0)-| | | | | | | |   mayRaise=[]-| | | | | | | catch ExceptionFailure-| | | | | | |   minReads=(Right 1)-| | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | <ok>-| | | | | | | | | pushValue (\x_0 -> \x_1 -> x_0)-| | | | | | | | |   minReads=(Right 1)-| | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | | pushValue (\x_0 -> x_0)-| | | | | | | | |   minReads=(Right 1)-| | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | | | | | |   minReads=(Right 1)-| | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | | read Parsers.Nandlang.nandStringLetter-| | | | | | | | |   minReads=(Right 1)-| | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | | | | | |   minReads=(Right 0)-| | | | | | | | |   mayRaise=[]-| | | | | | | | | call <hidden>-| | | | | | | | |   minReads=(Right 0)-| | | | | | | | |   mayRaise=[]-| | | | | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | | | | | |   minReads=(Right 0)-| | | | | | | | |   mayRaise=[]-| | | | | | | | | commit ExceptionFailure-| | | | | | | | |   minReads=(Right 0)-| | | | | | | | |   mayRaise=[]-| | | | | | | | | refJoin <hidden>-| | | | | | | | |   minReads=(Right 0)-| | | | | | | | |   mayRaise=[]-| | | | | | | | <ko>-| | | | | | | | | pushInput-| | | | | | | | |   minReads=(Right 2)-| | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | | lift2Value (\(Data.Text.Internal.Text _ i_0 _) (Data.Text.Internal.Text _-| | | | | | | | |                                                                j_1-| | | | | | | | |                                                                _) -> i_0 GHC.Classes.== j_1)-| | | | | | | | |   minReads=(Right 2)-| | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | | choicesBranch [\x_0 -> x_0]-| | | | | | | | |   minReads=(Right 2)-| | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | | | <branch>-| | | | | | | | | | | pushValue (\x_0 -> \x_1 -> x_0)-| | | | | | | | | | |   minReads=(Right 2)-| | | | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | | | | pushValue (\x_0 -> x_0)-| | | | | | | | | | |   minReads=(Right 2)-| | | | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | | | | | | | |   minReads=(Right 2)-| | | | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | | | | pushValue (\x_0 -> \x_1 -> x_0)-| | | | | | | | | | |   minReads=(Right 2)-| | | | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | | | | pushValue '\\'-| | | | | | | | | | |   minReads=(Right 2)-| | | | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | | | | | | | |   minReads=(Right 2)-| | | | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | | | | read ((GHC.Classes.==) '\\')-| | | | | | | | | | |   minReads=(Right 2)-| | | | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | | | | | | | |   minReads=(Right 1)-| | | | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | | | | | | | |   minReads=(Right 1)-| | | | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | | | | pushValue (\x_0 -> \x_1 -> x_0)-| | | | | | | | | | |   minReads=(Right 1)-| | | | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | | | | pushValue (\x_0 -> x_0)-| | | | | | | | | | |   minReads=(Right 1)-| | | | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | | | | | | | |   minReads=(Right 1)-| | | | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | | | | read (\t_0 -> ('0' GHC.Classes.== t_0) GHC.Classes.|| (('t' GHC.Classes.== t_0) GHC.Classes.|| (('n' GHC.Classes.== t_0) GHC.Classes.|| (('v' GHC.Classes.== t_0) GHC.Classes.|| (('f' GHC.Classes.== t_0) GHC.Classes.|| (('r' GHC.Classes.== t_0) GHC.Classes.|| GHC.Types.False))))))-| | | | | | | | | | |   minReads=(Right 1)-| | | | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | | | | | | | |   minReads=(Right 0)-| | | | | | | | | | |   mayRaise=[]-| | | | | | | | | | | call <hidden>-| | | | | | | | | | |   minReads=(Right 0)-| | | | | | | | | | |   mayRaise=[]-| | | | | | | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | | | | | | | |   minReads=(Right 0)-| | | | | | | | | | |   mayRaise=[]-| | | | | | | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | | | | | | | |   minReads=(Right 0)-| | | | | | | | | | |   mayRaise=[]-| | | | | | | | | | | refJoin <hidden>-| | | | | | | | | | |   minReads=(Right 0)-| | | | | | | | | | |   mayRaise=[]-| | | | | | | | | | <default>-| | | | | | | | | | | fail []-| | | | | | | | | | |   minReads=(Left ExceptionFailure)-| | | | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | <default>-| | | | | | | fail []-| | | | | | |   minReads=(Left ExceptionFailure)-| | | | | | |   mayRaise=[ExceptionFailure]-| | <ko>-| | | pushInput-| | |   minReads=(Right 2)-| | |   mayRaise=[ExceptionFailure]-| | | lift2Value (\(Data.Text.Internal.Text _ i_0 _) (Data.Text.Internal.Text _-| | |                                                                j_1-| | |                                                                _) -> i_0 GHC.Classes.== j_1)-| | |   minReads=(Right 2)-| | |   mayRaise=[ExceptionFailure]-| | | choicesBranch [\x_0 -> x_0]-| | |   minReads=(Right 2)-| | |   mayRaise=[ExceptionFailure]-| | | | <branch>-| | | | | pushValue (\x_0 -> \x_1 -> x_0)-| | | | |   minReads=(Right 2)-| | | | |   mayRaise=[ExceptionFailure]-| | | | | pushValue (\x_0 -> x_0)-| | | | |   minReads=(Right 2)-| | | | |   mayRaise=[ExceptionFailure]-| | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | |   minReads=(Right 2)-| | | | |   mayRaise=[ExceptionFailure]-| | | | | call <hidden>-| | | | |   minReads=(Right 2)-| | | | |   mayRaise=[ExceptionFailure]-| | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | |   minReads=(Right 0)-| | | | |   mayRaise=[ExceptionFailure]-| | | | | join <hidden>-| | | | |   minReads=(Right 0)-| | | | |   mayRaise=[]-| | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | | |   minReads=(Right 0)-| | | | | |   mayRaise=[]-| | | | | | ret-| | | | | |   minReads=(Right 0)-| | | | | |   mayRaise=[]-| | | | | catch ExceptionFailure-| | | | |   minReads=(Right 0)-| | | | |   mayRaise=[ExceptionFailure]-| | | | | | <ok>-| | | | | | | pushValue (\x_0 -> \x_1 -> x_0)-| | | | | | |   minReads=(Right 4)-| | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | pushValue GHC.Tuple.()-| | | | | | |   minReads=(Right 4)-| | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | | | |   minReads=(Right 4)-| | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | join <hidden>-| | | | | | |   minReads=(Right 0)-| | | | | | |   mayRaise=[]-| | | | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | | | | |   minReads=(Right 0)-| | | | | | | |   mayRaise=[]-| | | | | | | | commit ExceptionFailure-| | | | | | | |   minReads=(Right 0)-| | | | | | | |   mayRaise=[]-| | | | | | | | refJoin <hidden>-| | | | | | | |   minReads=(Right 0)-| | | | | | | |   mayRaise=[]-| | | | | | | catch ExceptionFailure-| | | | | | |   minReads=(Right 4)-| | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | <ok>-| | | | | | | | | pushValue (\x_0 -> \x_1 -> x_0)-| | | | | | | | |   minReads=(Right 4)-| | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | | pushValue (\x_0 -> \x_1 -> x_0)-| | | | | | | | |   minReads=(Right 4)-| | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | | pushValue (\x_0 -> x_0)-| | | | | | | | |   minReads=(Right 4)-| | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | | | | | |   minReads=(Right 4)-| | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | | call <hidden>-| | | | | | | | |   minReads=(Right 4)-| | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | | | | | |   minReads=(Right 2)-| | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | | join <hidden>-| | | | | | | | |   minReads=(Right 2)-| | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | | | | | | |   minReads=(Right 2)-| | | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | | | | | | |   minReads=(Right 2)-| | | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | | | call <hidden>-| | | | | | | | | |   minReads=(Right 2)-| | | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | | | | | | |   minReads=(Right 0)-| | | | | | | | | |   mayRaise=[]-| | | | | | | | | | commit ExceptionFailure-| | | | | | | | | |   minReads=(Right 0)-| | | | | | | | | |   mayRaise=[]-| | | | | | | | | | refJoin <hidden>-| | | | | | | | | |   minReads=(Right 0)-| | | | | | | | | |   mayRaise=[]-| | | | | | | | | catch ExceptionFailure-| | | | | | | | |   minReads=(Right 0)-| | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | | | <ok>-| | | | | | | | | | | pushValue (\x_0 -> \x_1 -> x_0)-| | | | | | | | | | |   minReads=(Right 2)-| | | | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | | | | pushValue GHC.Tuple.()-| | | | | | | | | | |   minReads=(Right 2)-| | | | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | | | | | | | |   minReads=(Right 2)-| | | | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | | | | pushValue (\x_0 -> \x_1 -> x_0)-| | | | | | | | | | |   minReads=(Right 2)-| | | | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | | | | pushValue (\x_0 -> x_0)-| | | | | | | | | | |   minReads=(Right 2)-| | | | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | | | | | | | |   minReads=(Right 2)-| | | | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | | | | call <hidden>-| | | | | | | | | | |   minReads=(Right 2)-| | | | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | | | | | | | |   minReads=(Right 0)-| | | | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | | | | pushValue (\x_0 -> \x_1 -> x_0)-| | | | | | | | | | |   minReads=(Right 0)-| | | | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | | | | pushValue (\x_0 -> x_0)-| | | | | | | | | | |   minReads=(Right 0)-| | | | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | | | | | | | |   minReads=(Right 0)-| | | | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | | | | pushValue ((\x_0 -> \x_1 -> \x_2 -> x_0 x_2 x_1) (\x_3 -> \x_4 -> x_3 x_4))-| | | | | | | | | | |   minReads=(Right 0)-| | | | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | | | | call <hidden>-| | | | | | | | | | |   minReads=(Right 0)-| | | | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | | | | | | | |   minReads=(Right 0)-| | | | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | | | | call <hidden>-| | | | | | | | | | |   minReads=(Right 0)-| | | | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | | | | | | | |   minReads=(Right 0)-| | | | | | | | | | |   mayRaise=[]-| | | | | | | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | | | | | | | |   minReads=(Right 0)-| | | | | | | | | | |   mayRaise=[]-| | | | | | | | | | | call <hidden>-| | | | | | | | | | |   minReads=(Right 0)-| | | | | | | | | | |   mayRaise=[]-| | | | | | | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | | | | | | | |   minReads=(Right 0)-| | | | | | | | | | |   mayRaise=[]-| | | | | | | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | | | | | | | |   minReads=(Right 0)-| | | | | | | | | | |   mayRaise=[]-| | | | | | | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | | | | | | | |   minReads=(Right 0)-| | | | | | | | | | |   mayRaise=[]-| | | | | | | | | | | commit ExceptionFailure-| | | | | | | | | | |   minReads=(Right 0)-| | | | | | | | | | |   mayRaise=[]-| | | | | | | | | | | refJoin <hidden>-| | | | | | | | | | |   minReads=(Right 0)-| | | | | | | | | | |   mayRaise=[]-| | | | | | | | | | <ko>-| | | | | | | | | | | pushInput-| | | | | | | | | | |   minReads=(Right 0)-| | | | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | | | | lift2Value (\(Data.Text.Internal.Text _ i_0 _) (Data.Text.Internal.Text _-| | | | | | | | | | |                                                                j_1-| | | | | | | | | | |                                                                _) -> i_0 GHC.Classes.== j_1)-| | | | | | | | | | |   minReads=(Right 0)-| | | | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | | | | choicesBranch [\x_0 -> x_0]-| | | | | | | | | | |   minReads=(Right 0)-| | | | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | | | | | <branch>-| | | | | | | | | | | | | call <hidden>-| | | | | | | | | | | | |   minReads=(Right 0)-| | | | | | | | | | | | |   mayRaise=[]-| | | | | | | | | | | | | refJoin <hidden>-| | | | | | | | | | | | |   minReads=(Right 0)-| | | | | | | | | | | | |   mayRaise=[]-| | | | | | | | | | | | <default>-| | | | | | | | | | | | | fail []-| | | | | | | | | | | | |   minReads=(Left ExceptionFailure)-| | | | | | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | <ko>-| | | | | | | | | pushInput-| | | | | | | | |   minReads=(Right 5)-| | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | | lift2Value (\(Data.Text.Internal.Text _ i_0 _) (Data.Text.Internal.Text _-| | | | | | | | |                                                                j_1-| | | | | | | | |                                                                _) -> i_0 GHC.Classes.== j_1)-| | | | | | | | |   minReads=(Right 5)-| | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | | choicesBranch [\x_0 -> x_0]-| | | | | | | | |   minReads=(Right 5)-| | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | | | <branch>-| | | | | | | | | | | call <hidden>-| | | | | | | | | | |   minReads=(Right 5)-| | | | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | | | | refJoin <hidden>-| | | | | | | | | | |   minReads=(Right 0)-| | | | | | | | | | |   mayRaise=[]-| | | | | | | | | | <default>-| | | | | | | | | | | fail []-| | | | | | | | | | |   minReads=(Left ExceptionFailure)-| | | | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | <ko>-| | | | | | | pushInput-| | | | | | |   minReads=(Right 0)-| | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | lift2Value (\(Data.Text.Internal.Text _ i_0 _) (Data.Text.Internal.Text _-| | | | | | |                                                                j_1-| | | | | | |                                                                _) -> i_0 GHC.Classes.== j_1)-| | | | | | |   minReads=(Right 0)-| | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | choicesBranch [\x_0 -> x_0]-| | | | | | |   minReads=(Right 0)-| | | | | | |   mayRaise=[ExceptionFailure]-| | | | | | | | <branch>-| | | | | | | | | call <hidden>-| | | | | | | | |   minReads=(Right 0)-| | | | | | | | |   mayRaise=[]-| | | | | | | | | refJoin <hidden>-| | | | | | | | |   minReads=(Right 0)-| | | | | | | | |   mayRaise=[]-| | | | | | | | <default>-| | | | | | | | | fail []-| | | | | | | | |   minReads=(Left ExceptionFailure)-| | | | | | | | |   mayRaise=[ExceptionFailure]-| | | | <default>-| | | | | fail []-| | | | |   minReads=(Left ExceptionFailure)-| | | | |   mayRaise=[ExceptionFailure]-let <hidden>-  minReads=(Right 2)-  mayRaise=[ExceptionFailure]-| pushValue (\x_0 -> \x_1 -> x_0)-|   minReads=(Right 2)-|   mayRaise=[ExceptionFailure]-| pushValue (\x_0 -> \x_1 -> x_0)-|   minReads=(Right 2)-|   mayRaise=[ExceptionFailure]-| pushValue '('-|   minReads=(Right 2)-|   mayRaise=[ExceptionFailure]-| lift2Value (\x_0 -> \x_1 -> x_0 x_1)-|   minReads=(Right 2)-|   mayRaise=[ExceptionFailure]-| read ((GHC.Classes.==) '(')-|   minReads=(Right 2)-|   mayRaise=[ExceptionFailure]-| lift2Value (\x_0 -> \x_1 -> x_0 x_1)-|   minReads=(Right 1)-|   mayRaise=[ExceptionFailure]-| lift2Value (\x_0 -> \x_1 -> x_0 x_1)-|   minReads=(Right 1)-|   mayRaise=[ExceptionFailure]-| call <hidden>-|   minReads=(Right 1)-|   mayRaise=[ExceptionFailure]-| lift2Value (\x_0 -> \x_1 -> x_0 x_1)-|   minReads=(Right 0)-|   mayRaise=[]-| ret-|   minReads=(Right 0)-|   mayRaise=[]-let <hidden>-  minReads=(Right 2)-  mayRaise=[ExceptionFailure]-| pushValue (\x_0 -> \x_1 -> x_0)-|   minReads=(Right 2)-|   mayRaise=[ExceptionFailure]-| pushValue (\x_0 -> \x_1 -> x_0)-|   minReads=(Right 2)-|   mayRaise=[ExceptionFailure]-| pushValue ')'-|   minReads=(Right 2)-|   mayRaise=[ExceptionFailure]-| lift2Value (\x_0 -> \x_1 -> x_0 x_1)-|   minReads=(Right 2)-|   mayRaise=[ExceptionFailure]-| read ((GHC.Classes.==) ')')-|   minReads=(Right 2)-|   mayRaise=[ExceptionFailure]-| lift2Value (\x_0 -> \x_1 -> x_0 x_1)-|   minReads=(Right 1)-|   mayRaise=[ExceptionFailure]-| lift2Value (\x_0 -> \x_1 -> x_0 x_1)-|   minReads=(Right 1)-|   mayRaise=[ExceptionFailure]-| call <hidden>-|   minReads=(Right 1)-|   mayRaise=[ExceptionFailure]-| lift2Value (\x_0 -> \x_1 -> x_0 x_1)-|   minReads=(Right 0)-|   mayRaise=[]-| ret-|   minReads=(Right 0)-|   mayRaise=[]-let <hidden>-  minReads=(Right 2)-  mayRaise=[ExceptionFailure]-| pushValue (\x_0 -> \x_1 -> x_0)-|   minReads=(Right 2)-|   mayRaise=[ExceptionFailure]-| pushValue (\x_0 -> \x_1 -> x_0)-|   minReads=(Right 2)-|   mayRaise=[ExceptionFailure]-| pushValue ','-|   minReads=(Right 2)-|   mayRaise=[ExceptionFailure]-| lift2Value (\x_0 -> \x_1 -> x_0 x_1)-|   minReads=(Right 2)-|   mayRaise=[ExceptionFailure]-| read ((GHC.Classes.==) ',')-|   minReads=(Right 2)-|   mayRaise=[ExceptionFailure]-| lift2Value (\x_0 -> \x_1 -> x_0 x_1)-|   minReads=(Right 1)-|   mayRaise=[ExceptionFailure]-| lift2Value (\x_0 -> \x_1 -> x_0 x_1)-|   minReads=(Right 1)-|   mayRaise=[ExceptionFailure]-| call <hidden>-|   minReads=(Right 1)-|   mayRaise=[ExceptionFailure]-| lift2Value (\x_0 -> \x_1 -> x_0 x_1)-|   minReads=(Right 0)-|   mayRaise=[]-| ret-|   minReads=(Right 0)-|   mayRaise=[]-let <hidden>-  minReads=(Right 2)-  mayRaise=[ExceptionFailure]-| pushValue (\x_0 -> \x_1 -> x_0)-|   minReads=(Right 2)-|   mayRaise=[ExceptionFailure]-| pushValue (\x_0 -> \x_1 -> x_0)-|   minReads=(Right 2)-|   mayRaise=[ExceptionFailure]-| pushValue ';'-|   minReads=(Right 2)-|   mayRaise=[ExceptionFailure]-| lift2Value (\x_0 -> \x_1 -> x_0 x_1)-|   minReads=(Right 2)-|   mayRaise=[ExceptionFailure]-| read ((GHC.Classes.==) ';')-|   minReads=(Right 2)-|   mayRaise=[ExceptionFailure]-| lift2Value (\x_0 -> \x_1 -> x_0 x_1)-|   minReads=(Right 1)-|   mayRaise=[ExceptionFailure]-| lift2Value (\x_0 -> \x_1 -> x_0 x_1)-|   minReads=(Right 1)-|   mayRaise=[ExceptionFailure]-| call <hidden>-|   minReads=(Right 1)-|   mayRaise=[ExceptionFailure]-| lift2Value (\x_0 -> \x_1 -> x_0 x_1)-|   minReads=(Right 0)-|   mayRaise=[]-| ret-|   minReads=(Right 0)-|   mayRaise=[]-let <hidden>-  minReads=(Right 2)-  mayRaise=[ExceptionFailure]-| pushValue (\x_0 -> \x_1 -> x_0)-|   minReads=(Right 2)-|   mayRaise=[ExceptionFailure]-| pushValue (\x_0 -> x_0)-|   minReads=(Right 2)-|   mayRaise=[ExceptionFailure]-| lift2Value (\x_0 -> \x_1 -> x_0 x_1)-|   minReads=(Right 2)-|   mayRaise=[ExceptionFailure]-| call <hidden>-|   minReads=(Right 2)-|   mayRaise=[ExceptionFailure]-| lift2Value (\x_0 -> \x_1 -> x_0 x_1)-|   minReads=(Right 0)-|   mayRaise=[ExceptionFailure]-| join <hidden>-|   minReads=(Right 0)-|   mayRaise=[]-| | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| |   minReads=(Right 0)-| |   mayRaise=[]-| | ret-| |   minReads=(Right 0)-| |   mayRaise=[]-| catch ExceptionFailure-|   minReads=(Right 0)-|   mayRaise=[ExceptionFailure]-| | <ok>-| | | pushValue (\x_0 -> \x_1 -> x_0)-| | |   minReads=(Right 5)-| | |   mayRaise=[ExceptionFailure]-| | | pushValue GHC.Tuple.()-| | |   minReads=(Right 5)-| | |   mayRaise=[ExceptionFailure]-| | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | |   minReads=(Right 5)-| | |   mayRaise=[ExceptionFailure]-| | | call <hidden>-| | |   minReads=(Right 5)-| | |   mayRaise=[ExceptionFailure]-| | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | |   minReads=(Right 0)-| | |   mayRaise=[]-| | | commit ExceptionFailure-| | |   minReads=(Right 0)-| | |   mayRaise=[]-| | | refJoin <hidden>-| | |   minReads=(Right 0)-| | |   mayRaise=[]-| | <ko>-| | | pushInput-| | |   minReads=(Right 0)-| | |   mayRaise=[ExceptionFailure]-| | | lift2Value (\(Data.Text.Internal.Text _ i_0 _) (Data.Text.Internal.Text _-| | |                                                                j_1-| | |                                                                _) -> i_0 GHC.Classes.== j_1)-| | |   minReads=(Right 0)-| | |   mayRaise=[ExceptionFailure]-| | | choicesBranch [\x_0 -> x_0]-| | |   minReads=(Right 0)-| | |   mayRaise=[ExceptionFailure]-| | | | <branch>-| | | | | call <hidden>-| | | | |   minReads=(Right 0)-| | | | |   mayRaise=[]-| | | | | refJoin <hidden>-| | | | |   minReads=(Right 0)-| | | | |   mayRaise=[]-| | | | <default>-| | | | | fail []-| | | | |   minReads=(Left ExceptionFailure)-| | | | |   mayRaise=[ExceptionFailure]-let <hidden>-  minReads=(Right 2)-  mayRaise=[ExceptionFailure]-| pushValue (\x_0 -> \x_1 -> x_0)-|   minReads=(Right 2)-|   mayRaise=[ExceptionFailure]-| pushValue (\x_0 -> x_0)-|   minReads=(Right 2)-|   mayRaise=[ExceptionFailure]-| lift2Value (\x_0 -> \x_1 -> x_0 x_1)-|   minReads=(Right 2)-|   mayRaise=[ExceptionFailure]-| call <hidden>-|   minReads=(Right 2)-|   mayRaise=[ExceptionFailure]-| lift2Value (\x_0 -> \x_1 -> x_0 x_1)-|   minReads=(Right 0)-|   mayRaise=[ExceptionFailure]-| pushValue (\x_0 -> \x_1 -> x_0)-|   minReads=(Right 0)-|   mayRaise=[ExceptionFailure]-| pushValue (\x_0 -> x_0)-|   minReads=(Right 0)-|   mayRaise=[ExceptionFailure]-| lift2Value (\x_0 -> \x_1 -> x_0 x_1)-|   minReads=(Right 0)-|   mayRaise=[ExceptionFailure]-| pushValue ((\x_0 -> \x_1 -> \x_2 -> x_0 x_2 x_1) (\x_3 -> \x_4 -> x_3 x_4))-|   minReads=(Right 0)-|   mayRaise=[ExceptionFailure]-| call <hidden>-|   minReads=(Right 0)-|   mayRaise=[ExceptionFailure]-| lift2Value (\x_0 -> \x_1 -> x_0 x_1)-|   minReads=(Right 0)-|   mayRaise=[ExceptionFailure]-| call <hidden>-|   minReads=(Right 0)-|   mayRaise=[ExceptionFailure]-| lift2Value (\x_0 -> \x_1 -> x_0 x_1)-|   minReads=(Right 0)-|   mayRaise=[]-| lift2Value (\x_0 -> \x_1 -> x_0 x_1)-|   minReads=(Right 0)-|   mayRaise=[]-| call <hidden>-|   minReads=(Right 0)-|   mayRaise=[]-| lift2Value (\x_0 -> \x_1 -> x_0 x_1)-|   minReads=(Right 0)-|   mayRaise=[]-| lift2Value (\x_0 -> \x_1 -> x_0 x_1)-|   minReads=(Right 0)-|   mayRaise=[]-| ret-|   minReads=(Right 0)-|   mayRaise=[]-let <hidden>-  minReads=(Right 2)-  mayRaise=[ExceptionFailure]-| pushValue (\x_0 -> \x_1 -> x_0)-|   minReads=(Right 2)-|   mayRaise=[ExceptionFailure]-| pushValue (\x_0 -> x_0)-|   minReads=(Right 2)-|   mayRaise=[ExceptionFailure]-| lift2Value (\x_0 -> \x_1 -> x_0 x_1)-|   minReads=(Right 2)-|   mayRaise=[ExceptionFailure]-| catch ExceptionFailure-|   minReads=(Right 2)-|   mayRaise=[ExceptionFailure]-| | <ok>-| | | pushValue (\x_0 -> \x_1 -> x_0)-| | |   minReads=(Right 2)-| | |   mayRaise=[ExceptionFailure]-| | | pushValue (\x_0 -> x_0)-| | |   minReads=(Right 2)-| | |   mayRaise=[ExceptionFailure]-| | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | |   minReads=(Right 2)-| | |   mayRaise=[ExceptionFailure]-| | | read Parsers.Nandlang.nandIdentStart-| | |   minReads=(Right 2)-| | |   mayRaise=[ExceptionFailure]-| | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | |   minReads=(Right 1)-| | |   mayRaise=[ExceptionFailure]-| | | pushValue (\x_0 -> \x_1 -> x_0)-| | |   minReads=(Right 1)-| | |   mayRaise=[ExceptionFailure]-| | | pushValue (\x_0 -> x_0)-| | |   minReads=(Right 1)-| | |   mayRaise=[ExceptionFailure]-| | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | |   minReads=(Right 1)-| | |   mayRaise=[ExceptionFailure]-| | | pushValue ((\x_0 -> \x_1 -> \x_2 -> x_0 x_2 x_1) (\x_3 -> \x_4 -> x_3 x_4))-| | |   minReads=(Right 1)-| | |   mayRaise=[ExceptionFailure]-| | | call <hidden>-| | |   minReads=(Right 1)-| | |   mayRaise=[ExceptionFailure]-| | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | |   minReads=(Right 0)-| | |   mayRaise=[ExceptionFailure]-| | | call <hidden>-| | |   minReads=(Right 0)-| | |   mayRaise=[ExceptionFailure]-| | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | |   minReads=(Right 0)-| | |   mayRaise=[]-| | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | |   minReads=(Right 0)-| | |   mayRaise=[]-| | | call <hidden>-| | |   minReads=(Right 0)-| | |   mayRaise=[]-| | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | |   minReads=(Right 1)-| | |   mayRaise=[ExceptionFailure]-| | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | |   minReads=(Right 1)-| | |   mayRaise=[ExceptionFailure]-| | | commit ExceptionFailure-| | |   minReads=(Right 1)-| | |   mayRaise=[ExceptionFailure]-| | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | |   minReads=(Right 1)-| | |   mayRaise=[ExceptionFailure]-| | | call <hidden>-| | |   minReads=(Right 1)-| | |   mayRaise=[ExceptionFailure]-| | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | |   minReads=(Right 0)-| | |   mayRaise=[]-| | | ret-| | |   minReads=(Right 0)-| | |   mayRaise=[]-| | <ko>-| | | loadInput-| | |   minReads=(Left ExceptionFailure)-| | |   mayRaise=[ExceptionFailure]-| | | fail []-| | |   minReads=(Left ExceptionFailure)-| | |   mayRaise=[ExceptionFailure]-let <hidden>-  minReads=(Right 4)-  mayRaise=[ExceptionFailure]-| pushValue (\x_0 -> \x_1 -> x_0)-|   minReads=(Right 4)-|   mayRaise=[ExceptionFailure]-| pushValue (\x_0 -> \x_1 -> x_0)-|   minReads=(Right 4)-|   mayRaise=[ExceptionFailure]-| pushValue (\x_0 -> x_0)-|   minReads=(Right 4)-|   mayRaise=[ExceptionFailure]-| lift2Value (\x_0 -> \x_1 -> x_0 x_1)-|   minReads=(Right 4)-|   mayRaise=[ExceptionFailure]-| pushValue (\x_0 -> \x_1 -> x_0)-|   minReads=(Right 4)-|   mayRaise=[ExceptionFailure]-| pushValue (\x_0 -> \x_1 -> x_0)-|   minReads=(Right 4)-|   mayRaise=[ExceptionFailure]-| pushValue '{'-|   minReads=(Right 4)-|   mayRaise=[ExceptionFailure]-| lift2Value (\x_0 -> \x_1 -> x_0 x_1)-|   minReads=(Right 4)-|   mayRaise=[ExceptionFailure]-| read ((GHC.Classes.==) '{')-|   minReads=(Right 4)-|   mayRaise=[ExceptionFailure]-| lift2Value (\x_0 -> \x_1 -> x_0 x_1)-|   minReads=(Right 3)-|   mayRaise=[ExceptionFailure]-| lift2Value (\x_0 -> \x_1 -> x_0 x_1)-|   minReads=(Right 3)-|   mayRaise=[ExceptionFailure]-| call <hidden>-|   minReads=(Right 3)-|   mayRaise=[ExceptionFailure]-| lift2Value (\x_0 -> \x_1 -> x_0 x_1)-|   minReads=(Right 1)-|   mayRaise=[ExceptionFailure]-| lift2Value (\x_0 -> \x_1 -> x_0 x_1)-|   minReads=(Right 1)-|   mayRaise=[ExceptionFailure]-| pushValue (\x_0 -> \x_1 -> x_0)-|   minReads=(Right 1)-|   mayRaise=[ExceptionFailure]-| pushValue (\x_0 -> x_0)-|   minReads=(Right 1)-|   mayRaise=[ExceptionFailure]-| lift2Value (\x_0 -> \x_1 -> x_0 x_1)-|   minReads=(Right 1)-|   mayRaise=[ExceptionFailure]-| pushValue ((\x_0 -> \x_1 -> \x_2 -> x_0 x_2 x_1) (\x_3 -> \x_4 -> x_3 x_4))-|   minReads=(Right 1)-|   mayRaise=[ExceptionFailure]-| call <hidden>-|   minReads=(Right 1)-|   mayRaise=[ExceptionFailure]-| lift2Value (\x_0 -> \x_1 -> x_0 x_1)-|   minReads=(Right 0)-|   mayRaise=[ExceptionFailure]-| call <hidden>-|   minReads=(Right 0)-|   mayRaise=[ExceptionFailure]-| lift2Value (\x_0 -> \x_1 -> x_0 x_1)-|   minReads=(Right 0)-|   mayRaise=[]-| lift2Value (\x_0 -> \x_1 -> x_0 x_1)-|   minReads=(Right 0)-|   mayRaise=[]-| call <hidden>-|   minReads=(Right 0)-|   mayRaise=[]-| lift2Value (\x_0 -> \x_1 -> x_0 x_1)-|   minReads=(Right 1)-|   mayRaise=[ExceptionFailure]-| lift2Value (\x_0 -> \x_1 -> x_0 x_1)-|   minReads=(Right 1)-|   mayRaise=[ExceptionFailure]-| lift2Value (\x_0 -> \x_1 -> x_0 x_1)-|   minReads=(Right 1)-|   mayRaise=[ExceptionFailure]-| pushValue (\x_0 -> \x_1 -> x_0)-|   minReads=(Right 1)-|   mayRaise=[ExceptionFailure]-| pushValue (\x_0 -> \x_1 -> x_0)-|   minReads=(Right 1)-|   mayRaise=[ExceptionFailure]-| pushValue '}'-|   minReads=(Right 1)-|   mayRaise=[ExceptionFailure]-| lift2Value (\x_0 -> \x_1 -> x_0 x_1)-|   minReads=(Right 1)-|   mayRaise=[ExceptionFailure]-| read ((GHC.Classes.==) '}')-|   minReads=(Right 1)-|   mayRaise=[ExceptionFailure]-| lift2Value (\x_0 -> \x_1 -> x_0 x_1)-|   minReads=(Right 0)-|   mayRaise=[]-| lift2Value (\x_0 -> \x_1 -> x_0 x_1)-|   minReads=(Right 0)-|   mayRaise=[]-| call <hidden>-|   minReads=(Right 0)-|   mayRaise=[]-| lift2Value (\x_0 -> \x_1 -> x_0 x_1)-|   minReads=(Right 0)-|   mayRaise=[]-| lift2Value (\x_0 -> \x_1 -> x_0 x_1)-|   minReads=(Right 0)-|   mayRaise=[]-| ret-|   minReads=(Right 0)-|   mayRaise=[]-let <hidden>-  minReads=(Right 5)-  mayRaise=[ExceptionFailure]-| pushValue (\x_0 -> \x_1 -> x_0)-|   minReads=(Right 5)-|   mayRaise=[ExceptionFailure]-| pushValue (\x_0 -> \x_1 -> x_0)-|   minReads=(Right 5)-|   mayRaise=[ExceptionFailure]-| pushValue (\x_0 -> x_0)-|   minReads=(Right 5)-|   mayRaise=[ExceptionFailure]-| lift2Value (\x_0 -> \x_1 -> x_0 x_1)-|   minReads=(Right 5)-|   mayRaise=[ExceptionFailure]-| pushValue (\x_0 -> \x_1 -> x_0)-|   minReads=(Right 5)-|   mayRaise=[ExceptionFailure]-| pushValue (\x_0 -> \x_1 -> x_0)-|   minReads=(Right 5)-|   mayRaise=[ExceptionFailure]-| pushValue '['-|   minReads=(Right 5)-|   mayRaise=[ExceptionFailure]-| lift2Value (\x_0 -> \x_1 -> x_0 x_1)-|   minReads=(Right 5)-|   mayRaise=[ExceptionFailure]-| read ((GHC.Classes.==) '[')-|   minReads=(Right 5)-|   mayRaise=[ExceptionFailure]-| lift2Value (\x_0 -> \x_1 -> x_0 x_1)-|   minReads=(Right 4)-|   mayRaise=[ExceptionFailure]-| lift2Value (\x_0 -> \x_1 -> x_0 x_1)-|   minReads=(Right 4)-|   mayRaise=[ExceptionFailure]-| call <hidden>-|   minReads=(Right 4)-|   mayRaise=[ExceptionFailure]-| lift2Value (\x_0 -> \x_1 -> x_0 x_1)-|   minReads=(Right 2)-|   mayRaise=[ExceptionFailure]-| lift2Value (\x_0 -> \x_1 -> x_0 x_1)-|   minReads=(Right 2)-|   mayRaise=[ExceptionFailure]-| pushValue (\x_0 -> \x_1 -> x_0)-|   minReads=(Right 2)-|   mayRaise=[ExceptionFailure]-| pushValue (\x_0 -> x_0)-|   minReads=(Right 2)-|   mayRaise=[ExceptionFailure]-| lift2Value (\x_0 -> \x_1 -> x_0 x_1)-|   minReads=(Right 2)-|   mayRaise=[ExceptionFailure]-| call <hidden>-|   minReads=(Right 2)-|   mayRaise=[ExceptionFailure]-| lift2Value (\x_0 -> \x_1 -> x_0 x_1)-|   minReads=(Right 1)-|   mayRaise=[ExceptionFailure]-| pushValue (\x_0 -> \x_1 -> x_0)-|   minReads=(Right 1)-|   mayRaise=[ExceptionFailure]-| pushValue (\x_0 -> x_0)-|   minReads=(Right 1)-|   mayRaise=[ExceptionFailure]-| lift2Value (\x_0 -> \x_1 -> x_0 x_1)-|   minReads=(Right 1)-|   mayRaise=[ExceptionFailure]-| pushValue ((\x_0 -> \x_1 -> \x_2 -> x_0 x_2 x_1) (\x_3 -> \x_4 -> x_3 x_4))-|   minReads=(Right 1)-|   mayRaise=[ExceptionFailure]-| pushValue GHC.Tuple.()-|   minReads=(Right 1)-|   mayRaise=[ExceptionFailure]-| lift2Value (\x_0 -> \x_1 -> x_0 x_1)-|   minReads=(Right 1)-|   mayRaise=[ExceptionFailure]-| call <hidden>-|   minReads=(Right 1)-|   mayRaise=[ExceptionFailure]-| lift2Value (\x_0 -> \x_1 -> x_0 x_1)-|   minReads=(Right 1)-|   mayRaise=[ExceptionFailure]-| lift2Value (\x_0 -> \x_1 -> x_0 x_1)-|   minReads=(Right 1)-|   mayRaise=[ExceptionFailure]-| pushValue GHC.Tuple.()-|   minReads=(Right 1)-|   mayRaise=[ExceptionFailure]-| lift2Value (\x_0 -> \x_1 -> x_0 x_1)-|   minReads=(Right 1)-|   mayRaise=[ExceptionFailure]-| lift2Value (\x_0 -> \x_1 -> x_0 x_1)-|   minReads=(Right 1)-|   mayRaise=[ExceptionFailure]-| lift2Value (\x_0 -> \x_1 -> x_0 x_1)-|   minReads=(Right 1)-|   mayRaise=[ExceptionFailure]-| lift2Value (\x_0 -> \x_1 -> x_0 x_1)-|   minReads=(Right 1)-|   mayRaise=[ExceptionFailure]-| pushValue (\x_0 -> \x_1 -> x_0)-|   minReads=(Right 1)-|   mayRaise=[ExceptionFailure]-| pushValue (\x_0 -> \x_1 -> x_0)-|   minReads=(Right 1)-|   mayRaise=[ExceptionFailure]-| pushValue ']'-|   minReads=(Right 1)-|   mayRaise=[ExceptionFailure]-| lift2Value (\x_0 -> \x_1 -> x_0 x_1)-|   minReads=(Right 1)-|   mayRaise=[ExceptionFailure]-| read ((GHC.Classes.==) ']')-|   minReads=(Right 1)-|   mayRaise=[ExceptionFailure]-| lift2Value (\x_0 -> \x_1 -> x_0 x_1)-|   minReads=(Right 0)-|   mayRaise=[]-| lift2Value (\x_0 -> \x_1 -> x_0 x_1)-|   minReads=(Right 0)-|   mayRaise=[]-| call <hidden>-|   minReads=(Right 0)-|   mayRaise=[]-| lift2Value (\x_0 -> \x_1 -> x_0 x_1)-|   minReads=(Right 0)-|   mayRaise=[]-| lift2Value (\x_0 -> \x_1 -> x_0 x_1)-|   minReads=(Right 0)-|   mayRaise=[]-| ret-|   minReads=(Right 0)-|   mayRaise=[]-pushValue GHC.Show.show-  minReads=(Right 1)-  mayRaise=[ExceptionFailure]-pushValue (\x_0 -> \x_1 -> x_0)-  minReads=(Right 1)-  mayRaise=[ExceptionFailure]-pushValue (\x_0 -> \x_1 -> x_0)-  minReads=(Right 1)-  mayRaise=[ExceptionFailure]-pushValue (\x_0 -> x_0)-  minReads=(Right 1)-  mayRaise=[ExceptionFailure]-lift2Value (\x_0 -> \x_1 -> x_0 x_1)-  minReads=(Right 1)-  mayRaise=[ExceptionFailure]-call <hidden>-  minReads=(Right 1)-  mayRaise=[ExceptionFailure]-lift2Value (\x_0 -> \x_1 -> x_0 x_1)-  minReads=(Right 0)-  mayRaise=[ExceptionFailure]-pushValue (\x_0 -> \x_1 -> x_0)-  minReads=(Right 0)-  mayRaise=[ExceptionFailure]-pushValue (\x_0 -> x_0)-  minReads=(Right 0)-  mayRaise=[ExceptionFailure]-lift2Value (\x_0 -> \x_1 -> x_0 x_1)-  minReads=(Right 0)-  mayRaise=[ExceptionFailure]-pushValue ((\x_0 -> \x_1 -> \x_2 -> x_0 x_2 x_1) (\x_3 -> \x_4 -> x_3 x_4))-  minReads=(Right 0)-  mayRaise=[ExceptionFailure]-call <hidden>-  minReads=(Right 0)-  mayRaise=[ExceptionFailure]-lift2Value (\x_0 -> \x_1 -> x_0 x_1)-  minReads=(Right 0)-  mayRaise=[ExceptionFailure]-call <hidden>-  minReads=(Right 0)-  mayRaise=[ExceptionFailure]-lift2Value (\x_0 -> \x_1 -> x_0 x_1)-  minReads=(Right 0)-  mayRaise=[]-lift2Value (\x_0 -> \x_1 -> x_0 x_1)-  minReads=(Right 0)-  mayRaise=[]-call <hidden>-  minReads=(Right 0)-  mayRaise=[]-lift2Value (\x_0 -> \x_1 -> x_0 x_1)-  minReads=(Right 0)-  mayRaise=[ExceptionFailure]-lift2Value (\x_0 -> \x_1 -> x_0 x_1)-  minReads=(Right 0)-  mayRaise=[ExceptionFailure]-lift2Value (\x_0 -> \x_1 -> x_0 x_1)-  minReads=(Right 0)-  mayRaise=[ExceptionFailure]-join <hidden>-  minReads=(Right 0)-  mayRaise=[]-| lift2Value (\x_0 -> \x_1 -> x_0 x_1)-|   minReads=(Right 0)-|   mayRaise=[]-| lift2Value (\x_0 -> \x_1 -> x_0 x_1)-|   minReads=(Right 0)-|   mayRaise=[]-| ret-|   minReads=(Right 0)-|   mayRaise=[]-catch ExceptionFailure-  minReads=(Right 0)-  mayRaise=[ExceptionFailure]-| <ok>-| | catch ExceptionFailure-| |   minReads=(Right 0)-| |   mayRaise=[]-| | | <ok>-| | | | pushInput-| | | |   minReads=(Left ExceptionFailure)-| | | |   mayRaise=[ExceptionFailure]-| | | | read ((\x_0 -> \x_1 -> x_0) GHC.Types.True)-| | | |   minReads=(Left ExceptionFailure)-| | | |   mayRaise=[ExceptionFailure]-| | | | popValue-| | | |   minReads=(Left ExceptionFailure)-| | | |   mayRaise=[ExceptionFailure]-| | | | commit ExceptionFailure-| | | |   minReads=(Left ExceptionFailure)-| | | |   mayRaise=[ExceptionFailure]-| | | | loadInput-| | | |   minReads=(Left ExceptionFailure)-| | | |   mayRaise=[ExceptionFailure]-| | | | fail []-| | | |   minReads=(Left ExceptionFailure)-| | | |   mayRaise=[ExceptionFailure]-| | | <ko>-| | | | loadInput-| | | |   minReads=(Right 0)-| | | |   mayRaise=[]-| | | | pushValue GHC.Tuple.()-| | | |   minReads=(Right 0)-| | | |   mayRaise=[]-| | | | commit ExceptionFailure-| | | |   minReads=(Right 0)-| | | |   mayRaise=[]-| | | | refJoin <hidden>-| | | |   minReads=(Right 0)-| | | |   mayRaise=[]-| <ko>-| | pushInput-| |   minReads=(Left ExceptionFailure)-| |   mayRaise=[ExceptionFailure]-| | lift2Value (\(Data.Text.Internal.Text _ i_0 _) (Data.Text.Internal.Text _-| |                                                                j_1-| |                                                                _) -> i_0 GHC.Classes.== j_1)-| |   minReads=(Left ExceptionFailure)-| |   mayRaise=[ExceptionFailure]-| | choicesBranch [\x_0 -> x_0]-| |   minReads=(Left ExceptionFailure)-| |   mayRaise=[ExceptionFailure]-| | | <branch>-| | | | fail [FailureEnd]-| | | |   minReads=(Left ExceptionFailure)-| | | |   mayRaise=[ExceptionFailure]-| | | <default>-| | | | fail []-| | | |   minReads=(Left ExceptionFailure)-| | | |   mayRaise=[ExceptionFailure]
− test/Golden/Machine/G15.expected.txt 
@@ -1,96 +0,0 @@-pushValue GHC.Show.show-  minReads=(Right 2)-  mayRaise=[ExceptionFailure]-pushValue (\x_0 -> \x_1 -> x_0)-  minReads=(Right 2)-  mayRaise=[ExceptionFailure]-join <hidden>-  minReads=(Right 1)-  mayRaise=[ExceptionFailure]-| lift2Value (\x_0 -> \x_1 -> x_0 x_1)-|   minReads=(Right 1)-|   mayRaise=[ExceptionFailure]-| pushValue (\x_0 -> \x_1 -> x_0)-|   minReads=(Right 1)-|   mayRaise=[ExceptionFailure]-| pushValue 'c'-|   minReads=(Right 1)-|   mayRaise=[ExceptionFailure]-| lift2Value (\x_0 -> \x_1 -> x_0 x_1)-|   minReads=(Right 1)-|   mayRaise=[ExceptionFailure]-| read ((GHC.Classes.==) 'c')-|   minReads=(Right 1)-|   mayRaise=[ExceptionFailure]-| lift2Value (\x_0 -> \x_1 -> x_0 x_1)-|   minReads=(Right 0)-|   mayRaise=[]-| lift2Value (\x_0 -> \x_1 -> x_0 x_1)-|   minReads=(Right 0)-|   mayRaise=[]-| lift2Value (\x_0 -> \x_1 -> x_0 x_1)-|   minReads=(Right 0)-|   mayRaise=[]-| ret-|   minReads=(Right 0)-|   mayRaise=[]-catch ExceptionFailure-  minReads=(Right 1)-  mayRaise=[ExceptionFailure]-| <ok>-| | pushValue (\x_0 -> \x_1 -> x_0)-| |   minReads=(Right 1)-| |   mayRaise=[ExceptionFailure]-| | pushValue 'a'-| |   minReads=(Right 1)-| |   mayRaise=[ExceptionFailure]-| | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| |   minReads=(Right 1)-| |   mayRaise=[ExceptionFailure]-| | read ((GHC.Classes.==) 'a')-| |   minReads=(Right 1)-| |   mayRaise=[ExceptionFailure]-| | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| |   minReads=(Right 0)-| |   mayRaise=[]-| | commit ExceptionFailure-| |   minReads=(Right 0)-| |   mayRaise=[]-| | refJoin <hidden>-| |   minReads=(Right 0)-| |   mayRaise=[]-| <ko>-| | pushInput-| |   minReads=(Right 1)-| |   mayRaise=[ExceptionFailure]-| | lift2Value (\(Data.Text.Internal.Text _ i_0 _) (Data.Text.Internal.Text _-| |                                                                j_1-| |                                                                _) -> i_0 GHC.Classes.== j_1)-| |   minReads=(Right 1)-| |   mayRaise=[ExceptionFailure]-| | choicesBranch [\x_0 -> x_0]-| |   minReads=(Right 1)-| |   mayRaise=[ExceptionFailure]-| | | <branch>-| | | | pushValue (\x_0 -> \x_1 -> x_0)-| | | |   minReads=(Right 1)-| | | |   mayRaise=[ExceptionFailure]-| | | | pushValue 'b'-| | | |   minReads=(Right 1)-| | | |   mayRaise=[ExceptionFailure]-| | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | |   minReads=(Right 1)-| | | |   mayRaise=[ExceptionFailure]-| | | | read ((GHC.Classes.==) 'b')-| | | |   minReads=(Right 1)-| | | |   mayRaise=[ExceptionFailure]-| | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | |   minReads=(Right 0)-| | | |   mayRaise=[]-| | | | refJoin <hidden>-| | | |   minReads=(Right 0)-| | | |   mayRaise=[]-| | | <default>-| | | | fail []-| | | |   minReads=(Left ExceptionFailure)-| | | |   mayRaise=[ExceptionFailure]
− test/Golden/Machine/G16.expected.txt 
@@ -1,144 +0,0 @@-pushValue GHC.Show.show-  minReads=(Right 2)-  mayRaise=[ExceptionFailure]-pushValue (\x_0 -> \x_1 -> x_0)-  minReads=(Right 2)-  mayRaise=[ExceptionFailure]-join <hidden>-  minReads=(Right 1)-  mayRaise=[ExceptionFailure]-| lift2Value (\x_0 -> \x_1 -> x_0 x_1)-|   minReads=(Right 1)-|   mayRaise=[ExceptionFailure]-| pushValue (\x_0 -> \x_1 -> x_0)-|   minReads=(Right 1)-|   mayRaise=[ExceptionFailure]-| pushValue 'd'-|   minReads=(Right 1)-|   mayRaise=[ExceptionFailure]-| lift2Value (\x_0 -> \x_1 -> x_0 x_1)-|   minReads=(Right 1)-|   mayRaise=[ExceptionFailure]-| read ((GHC.Classes.==) 'd')-|   minReads=(Right 1)-|   mayRaise=[ExceptionFailure]-| lift2Value (\x_0 -> \x_1 -> x_0 x_1)-|   minReads=(Right 0)-|   mayRaise=[]-| lift2Value (\x_0 -> \x_1 -> x_0 x_1)-|   minReads=(Right 0)-|   mayRaise=[]-| lift2Value (\x_0 -> \x_1 -> x_0 x_1)-|   minReads=(Right 0)-|   mayRaise=[]-| ret-|   minReads=(Right 0)-|   mayRaise=[]-catch ExceptionFailure-  minReads=(Right 1)-  mayRaise=[ExceptionFailure]-| <ok>-| | join <hidden>-| |   minReads=(Right 1)-| |   mayRaise=[ExceptionFailure]-| | | commit ExceptionFailure-| | |   minReads=(Right 0)-| | |   mayRaise=[]-| | | refJoin <hidden>-| | |   minReads=(Right 0)-| | |   mayRaise=[]-| | catch ExceptionFailure-| |   minReads=(Right 1)-| |   mayRaise=[ExceptionFailure]-| | | <ok>-| | | | pushValue (\x_0 -> \x_1 -> x_0)-| | | |   minReads=(Right 1)-| | | |   mayRaise=[ExceptionFailure]-| | | | pushValue 'a'-| | | |   minReads=(Right 1)-| | | |   mayRaise=[ExceptionFailure]-| | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | |   minReads=(Right 1)-| | | |   mayRaise=[ExceptionFailure]-| | | | read ((GHC.Classes.==) 'a')-| | | |   minReads=(Right 1)-| | | |   mayRaise=[ExceptionFailure]-| | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | |   minReads=(Right 0)-| | | |   mayRaise=[]-| | | | commit ExceptionFailure-| | | |   minReads=(Right 0)-| | | |   mayRaise=[]-| | | | refJoin <hidden>-| | | |   minReads=(Right 0)-| | | |   mayRaise=[]-| | | <ko>-| | | | pushInput-| | | |   minReads=(Right 1)-| | | |   mayRaise=[ExceptionFailure]-| | | | lift2Value (\(Data.Text.Internal.Text _ i_0 _) (Data.Text.Internal.Text _-| | | |                                                                j_1-| | | |                                                                _) -> i_0 GHC.Classes.== j_1)-| | | |   minReads=(Right 1)-| | | |   mayRaise=[ExceptionFailure]-| | | | choicesBranch [\x_0 -> x_0]-| | | |   minReads=(Right 1)-| | | |   mayRaise=[ExceptionFailure]-| | | | | <branch>-| | | | | | pushValue (\x_0 -> \x_1 -> x_0)-| | | | | |   minReads=(Right 1)-| | | | | |   mayRaise=[ExceptionFailure]-| | | | | | pushValue 'b'-| | | | | |   minReads=(Right 1)-| | | | | |   mayRaise=[ExceptionFailure]-| | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | | |   minReads=(Right 1)-| | | | | |   mayRaise=[ExceptionFailure]-| | | | | | read ((GHC.Classes.==) 'b')-| | | | | |   minReads=(Right 1)-| | | | | |   mayRaise=[ExceptionFailure]-| | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | | |   minReads=(Right 0)-| | | | | |   mayRaise=[]-| | | | | | refJoin <hidden>-| | | | | |   minReads=(Right 0)-| | | | | |   mayRaise=[]-| | | | | <default>-| | | | | | fail []-| | | | | |   minReads=(Left ExceptionFailure)-| | | | | |   mayRaise=[ExceptionFailure]-| <ko>-| | pushInput-| |   minReads=(Right 1)-| |   mayRaise=[ExceptionFailure]-| | lift2Value (\(Data.Text.Internal.Text _ i_0 _) (Data.Text.Internal.Text _-| |                                                                j_1-| |                                                                _) -> i_0 GHC.Classes.== j_1)-| |   minReads=(Right 1)-| |   mayRaise=[ExceptionFailure]-| | choicesBranch [\x_0 -> x_0]-| |   minReads=(Right 1)-| |   mayRaise=[ExceptionFailure]-| | | <branch>-| | | | pushValue (\x_0 -> \x_1 -> x_0)-| | | |   minReads=(Right 1)-| | | |   mayRaise=[ExceptionFailure]-| | | | pushValue 'c'-| | | |   minReads=(Right 1)-| | | |   mayRaise=[ExceptionFailure]-| | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | |   minReads=(Right 1)-| | | |   mayRaise=[ExceptionFailure]-| | | | read ((GHC.Classes.==) 'c')-| | | |   minReads=(Right 1)-| | | |   mayRaise=[ExceptionFailure]-| | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | |   minReads=(Right 0)-| | | |   mayRaise=[]-| | | | refJoin <hidden>-| | | |   minReads=(Right 0)-| | | |   mayRaise=[]-| | | <default>-| | | | fail []-| | | |   minReads=(Left ExceptionFailure)-| | | |   mayRaise=[ExceptionFailure]
− test/Golden/Machine/G2.expected.txt 
@@ -1,98 +0,0 @@-pushValue GHC.Show.show-  minReads=(Right 3)-  mayRaise=[ExceptionFailure]-catch ExceptionFailure-  minReads=(Right 3)-  mayRaise=[ExceptionFailure]-| <ok>-| | pushValue (GHC.Types.:)-| |   minReads=(Right 3)-| |   mayRaise=[ExceptionFailure]-| | pushValue (\x_0 -> \x_1 -> x_0)-| |   minReads=(Right 3)-| |   mayRaise=[ExceptionFailure]-| | pushValue 'a'-| |   minReads=(Right 3)-| |   mayRaise=[ExceptionFailure]-| | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| |   minReads=(Right 3)-| |   mayRaise=[ExceptionFailure]-| | read ((GHC.Classes.==) 'a')-| |   minReads=(Right 3)-| |   mayRaise=[ExceptionFailure]-| | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| |   minReads=(Right 2)-| |   mayRaise=[ExceptionFailure]-| | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| |   minReads=(Right 2)-| |   mayRaise=[ExceptionFailure]-| | pushValue (GHC.Types.:)-| |   minReads=(Right 2)-| |   mayRaise=[ExceptionFailure]-| | pushValue (\x_0 -> \x_1 -> x_0)-| |   minReads=(Right 2)-| |   mayRaise=[ExceptionFailure]-| | pushValue 'b'-| |   minReads=(Right 2)-| |   mayRaise=[ExceptionFailure]-| | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| |   minReads=(Right 2)-| |   mayRaise=[ExceptionFailure]-| | read ((GHC.Classes.==) 'b')-| |   minReads=(Right 2)-| |   mayRaise=[ExceptionFailure]-| | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| |   minReads=(Right 1)-| |   mayRaise=[ExceptionFailure]-| | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| |   minReads=(Right 1)-| |   mayRaise=[ExceptionFailure]-| | pushValue (GHC.Types.:)-| |   minReads=(Right 1)-| |   mayRaise=[ExceptionFailure]-| | pushValue (\x_0 -> \x_1 -> x_0)-| |   minReads=(Right 1)-| |   mayRaise=[ExceptionFailure]-| | pushValue 'c'-| |   minReads=(Right 1)-| |   mayRaise=[ExceptionFailure]-| | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| |   minReads=(Right 1)-| |   mayRaise=[ExceptionFailure]-| | read ((GHC.Classes.==) 'c')-| |   minReads=(Right 1)-| |   mayRaise=[ExceptionFailure]-| | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| |   minReads=(Right 0)-| |   mayRaise=[]-| | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| |   minReads=(Right 0)-| |   mayRaise=[]-| | pushValue GHC.Types.[]-| |   minReads=(Right 0)-| |   mayRaise=[]-| | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| |   minReads=(Right 0)-| |   mayRaise=[]-| | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| |   minReads=(Right 0)-| |   mayRaise=[]-| | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| |   minReads=(Right 0)-| |   mayRaise=[]-| | commit ExceptionFailure-| |   minReads=(Right 0)-| |   mayRaise=[]-| | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| |   minReads=(Right 0)-| |   mayRaise=[]-| | ret-| |   minReads=(Right 0)-| |   mayRaise=[]-| <ko>-| | loadInput-| |   minReads=(Left ExceptionFailure)-| |   mayRaise=[ExceptionFailure]-| | fail []-| |   minReads=(Left ExceptionFailure)-| |   mayRaise=[ExceptionFailure]
− test/Golden/Machine/G3.expected.txt 
@@ -1,87 +0,0 @@-let <hidden>-  minReads=(Right 0)-  mayRaise=[ExceptionFailure]-| catch ExceptionFailure-|   minReads=(Right 0)-|   mayRaise=[ExceptionFailure]-| | <ok>-| | | pushValue (\x_0 -> \x_1 -> \x_2 -> x_0 (x_1 x_2))-| | |   minReads=(Right 1)-| | |   mayRaise=[ExceptionFailure]-| | | pushValue (GHC.Types.:)-| | |   minReads=(Right 1)-| | |   mayRaise=[ExceptionFailure]-| | | pushValue (\x_0 -> \x_1 -> x_0)-| | |   minReads=(Right 1)-| | |   mayRaise=[ExceptionFailure]-| | | pushValue 'a'-| | |   minReads=(Right 1)-| | |   mayRaise=[ExceptionFailure]-| | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | |   minReads=(Right 1)-| | |   mayRaise=[ExceptionFailure]-| | | read ((GHC.Classes.==) 'a')-| | |   minReads=(Right 1)-| | |   mayRaise=[ExceptionFailure]-| | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | |   minReads=(Right 0)-| | |   mayRaise=[ExceptionFailure]-| | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | |   minReads=(Right 0)-| | |   mayRaise=[ExceptionFailure]-| | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | |   minReads=(Right 0)-| | |   mayRaise=[ExceptionFailure]-| | | call <hidden>-| | |   minReads=(Right 0)-| | |   mayRaise=[ExceptionFailure]-| | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | |   minReads=(Right 0)-| | |   mayRaise=[]-| | | commit ExceptionFailure-| | |   minReads=(Right 0)-| | |   mayRaise=[]-| | | ret-| | |   minReads=(Right 0)-| | |   mayRaise=[]-| | <ko>-| | | pushInput-| | |   minReads=(Right 0)-| | |   mayRaise=[ExceptionFailure]-| | | lift2Value (\(Data.Text.Internal.Text _ i_0 _) (Data.Text.Internal.Text _-| | |                                                                j_1-| | |                                                                _) -> i_0 GHC.Classes.== j_1)-| | |   minReads=(Right 0)-| | |   mayRaise=[ExceptionFailure]-| | | choicesBranch [\x_0 -> x_0]-| | |   minReads=(Right 0)-| | |   mayRaise=[ExceptionFailure]-| | | | <branch>-| | | | | pushValue (\x_0 -> x_0)-| | | | |   minReads=(Right 0)-| | | | |   mayRaise=[]-| | | | | ret-| | | | |   minReads=(Right 0)-| | | | |   mayRaise=[]-| | | | <default>-| | | | | fail []-| | | | |   minReads=(Left ExceptionFailure)-| | | | |   mayRaise=[ExceptionFailure]-pushValue GHC.Show.show-  minReads=(Right 0)-  mayRaise=[ExceptionFailure]-call <hidden>-  minReads=(Right 0)-  mayRaise=[ExceptionFailure]-pushValue GHC.Types.[]-  minReads=(Right 0)-  mayRaise=[]-lift2Value (\x_0 -> \x_1 -> x_0 x_1)-  minReads=(Right 0)-  mayRaise=[]-lift2Value (\x_0 -> \x_1 -> x_0 x_1)-  minReads=(Right 0)-  mayRaise=[]-ret-  minReads=(Right 0)-  mayRaise=[]
− test/Golden/Machine/G4.expected.txt 
@@ -1,206 +0,0 @@-let <hidden>-  minReads=(Right 0)-  mayRaise=[ExceptionFailure]-| catch ExceptionFailure-|   minReads=(Right 0)-|   mayRaise=[ExceptionFailure]-| | <ok>-| | | pushValue (\x_0 -> \x_1 -> \x_2 -> x_0 (x_1 x_2))-| | |   minReads=(Right 4)-| | |   mayRaise=[ExceptionFailure]-| | | pushValue (GHC.Types.:)-| | |   minReads=(Right 4)-| | |   mayRaise=[ExceptionFailure]-| | | call <hidden>-| | |   minReads=(Right 4)-| | |   mayRaise=[ExceptionFailure]-| | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | |   minReads=(Right 0)-| | |   mayRaise=[ExceptionFailure]-| | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | |   minReads=(Right 0)-| | |   mayRaise=[ExceptionFailure]-| | | call <hidden>-| | |   minReads=(Right 0)-| | |   mayRaise=[ExceptionFailure]-| | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | |   minReads=(Right 0)-| | |   mayRaise=[]-| | | commit ExceptionFailure-| | |   minReads=(Right 0)-| | |   mayRaise=[]-| | | ret-| | |   minReads=(Right 0)-| | |   mayRaise=[]-| | <ko>-| | | pushInput-| | |   minReads=(Right 0)-| | |   mayRaise=[ExceptionFailure]-| | | lift2Value (\(Data.Text.Internal.Text _ i_0 _) (Data.Text.Internal.Text _-| | |                                                                j_1-| | |                                                                _) -> i_0 GHC.Classes.== j_1)-| | |   minReads=(Right 0)-| | |   mayRaise=[ExceptionFailure]-| | | choicesBranch [\x_0 -> x_0]-| | |   minReads=(Right 0)-| | |   mayRaise=[ExceptionFailure]-| | | | <branch>-| | | | | pushValue (\x_0 -> x_0)-| | | | |   minReads=(Right 0)-| | | | |   mayRaise=[]-| | | | | ret-| | | | |   minReads=(Right 0)-| | | | |   mayRaise=[]-| | | | <default>-| | | | | fail []-| | | | |   minReads=(Left ExceptionFailure)-| | | | |   mayRaise=[ExceptionFailure]-let <hidden>-  minReads=(Right 4)-  mayRaise=[ExceptionFailure]-| catch ExceptionFailure-|   minReads=(Right 4)-|   mayRaise=[ExceptionFailure]-| | <ok>-| | | pushValue (GHC.Types.:)-| | |   minReads=(Right 4)-| | |   mayRaise=[ExceptionFailure]-| | | pushValue (\x_0 -> \x_1 -> x_0)-| | |   minReads=(Right 4)-| | |   mayRaise=[ExceptionFailure]-| | | pushValue 'a'-| | |   minReads=(Right 4)-| | |   mayRaise=[ExceptionFailure]-| | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | |   minReads=(Right 4)-| | |   mayRaise=[ExceptionFailure]-| | | read ((GHC.Classes.==) 'a')-| | |   minReads=(Right 4)-| | |   mayRaise=[ExceptionFailure]-| | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | |   minReads=(Right 3)-| | |   mayRaise=[ExceptionFailure]-| | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | |   minReads=(Right 3)-| | |   mayRaise=[ExceptionFailure]-| | | pushValue (GHC.Types.:)-| | |   minReads=(Right 3)-| | |   mayRaise=[ExceptionFailure]-| | | pushValue (\x_0 -> \x_1 -> x_0)-| | |   minReads=(Right 3)-| | |   mayRaise=[ExceptionFailure]-| | | pushValue 'b'-| | |   minReads=(Right 3)-| | |   mayRaise=[ExceptionFailure]-| | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | |   minReads=(Right 3)-| | |   mayRaise=[ExceptionFailure]-| | | read ((GHC.Classes.==) 'b')-| | |   minReads=(Right 3)-| | |   mayRaise=[ExceptionFailure]-| | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | |   minReads=(Right 2)-| | |   mayRaise=[ExceptionFailure]-| | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | |   minReads=(Right 2)-| | |   mayRaise=[ExceptionFailure]-| | | pushValue (GHC.Types.:)-| | |   minReads=(Right 2)-| | |   mayRaise=[ExceptionFailure]-| | | pushValue (\x_0 -> \x_1 -> x_0)-| | |   minReads=(Right 2)-| | |   mayRaise=[ExceptionFailure]-| | | pushValue 'c'-| | |   minReads=(Right 2)-| | |   mayRaise=[ExceptionFailure]-| | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | |   minReads=(Right 2)-| | |   mayRaise=[ExceptionFailure]-| | | read ((GHC.Classes.==) 'c')-| | |   minReads=(Right 2)-| | |   mayRaise=[ExceptionFailure]-| | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | |   minReads=(Right 1)-| | |   mayRaise=[ExceptionFailure]-| | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | |   minReads=(Right 1)-| | |   mayRaise=[ExceptionFailure]-| | | pushValue (GHC.Types.:)-| | |   minReads=(Right 1)-| | |   mayRaise=[ExceptionFailure]-| | | pushValue (\x_0 -> \x_1 -> x_0)-| | |   minReads=(Right 1)-| | |   mayRaise=[ExceptionFailure]-| | | pushValue 'd'-| | |   minReads=(Right 1)-| | |   mayRaise=[ExceptionFailure]-| | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | |   minReads=(Right 1)-| | |   mayRaise=[ExceptionFailure]-| | | read ((GHC.Classes.==) 'd')-| | |   minReads=(Right 1)-| | |   mayRaise=[ExceptionFailure]-| | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | |   minReads=(Right 0)-| | |   mayRaise=[]-| | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | |   minReads=(Right 0)-| | |   mayRaise=[]-| | | pushValue GHC.Types.[]-| | |   minReads=(Right 0)-| | |   mayRaise=[]-| | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | |   minReads=(Right 0)-| | |   mayRaise=[]-| | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | |   minReads=(Right 0)-| | |   mayRaise=[]-| | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | |   minReads=(Right 0)-| | |   mayRaise=[]-| | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | |   minReads=(Right 0)-| | |   mayRaise=[]-| | | commit ExceptionFailure-| | |   minReads=(Right 0)-| | |   mayRaise=[]-| | | ret-| | |   minReads=(Right 0)-| | |   mayRaise=[]-| | <ko>-| | | loadInput-| | |   minReads=(Left ExceptionFailure)-| | |   mayRaise=[ExceptionFailure]-| | | fail []-| | |   minReads=(Left ExceptionFailure)-| | |   mayRaise=[ExceptionFailure]-pushValue GHC.Show.show-  minReads=(Right 4)-  mayRaise=[ExceptionFailure]-pushValue (GHC.Types.:)-  minReads=(Right 4)-  mayRaise=[ExceptionFailure]-call <hidden>-  minReads=(Right 4)-  mayRaise=[ExceptionFailure]-lift2Value (\x_0 -> \x_1 -> x_0 x_1)-  minReads=(Right 0)-  mayRaise=[ExceptionFailure]-call <hidden>-  minReads=(Right 0)-  mayRaise=[ExceptionFailure]-pushValue GHC.Types.[]-  minReads=(Right 0)-  mayRaise=[]-lift2Value (\x_0 -> \x_1 -> x_0 x_1)-  minReads=(Right 0)-  mayRaise=[]-lift2Value (\x_0 -> \x_1 -> x_0 x_1)-  minReads=(Right 0)-  mayRaise=[]-lift2Value (\x_0 -> \x_1 -> x_0 x_1)-  minReads=(Right 0)-  mayRaise=[]-ret-  minReads=(Right 0)-  mayRaise=[]
− test/Golden/Machine/G5.expected.txt 
@@ -1,277 +0,0 @@-let <hidden>-  minReads=(Right 0)-  mayRaise=[ExceptionFailure]-| catch ExceptionFailure-|   minReads=(Right 0)-|   mayRaise=[ExceptionFailure]-| | <ok>-| | | pushValue (\x_0 -> \x_1 -> \x_2 -> x_0 (x_1 x_2))-| | |   minReads=(Right 4)-| | |   mayRaise=[ExceptionFailure]-| | | pushValue (GHC.Types.:)-| | |   minReads=(Right 4)-| | |   mayRaise=[ExceptionFailure]-| | | call <hidden>-| | |   minReads=(Right 4)-| | |   mayRaise=[ExceptionFailure]-| | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | |   minReads=(Right 0)-| | |   mayRaise=[ExceptionFailure]-| | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | |   minReads=(Right 0)-| | |   mayRaise=[ExceptionFailure]-| | | call <hidden>-| | |   minReads=(Right 0)-| | |   mayRaise=[ExceptionFailure]-| | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | |   minReads=(Right 0)-| | |   mayRaise=[]-| | | commit ExceptionFailure-| | |   minReads=(Right 0)-| | |   mayRaise=[]-| | | ret-| | |   minReads=(Right 0)-| | |   mayRaise=[]-| | <ko>-| | | pushInput-| | |   minReads=(Right 0)-| | |   mayRaise=[ExceptionFailure]-| | | lift2Value (\(Data.Text.Internal.Text _ i_0 _) (Data.Text.Internal.Text _-| | |                                                                j_1-| | |                                                                _) -> i_0 GHC.Classes.== j_1)-| | |   minReads=(Right 0)-| | |   mayRaise=[ExceptionFailure]-| | | choicesBranch [\x_0 -> x_0]-| | |   minReads=(Right 0)-| | |   mayRaise=[ExceptionFailure]-| | | | <branch>-| | | | | pushValue (\x_0 -> x_0)-| | | | |   minReads=(Right 0)-| | | | |   mayRaise=[]-| | | | | ret-| | | | |   minReads=(Right 0)-| | | | |   mayRaise=[]-| | | | <default>-| | | | | fail []-| | | | |   minReads=(Left ExceptionFailure)-| | | | |   mayRaise=[ExceptionFailure]-let <hidden>-  minReads=(Right 4)-  mayRaise=[ExceptionFailure]-| catch ExceptionFailure-|   minReads=(Right 4)-|   mayRaise=[ExceptionFailure]-| | <ok>-| | | pushValue (GHC.Types.:)-| | |   minReads=(Right 4)-| | |   mayRaise=[ExceptionFailure]-| | | pushValue (\x_0 -> \x_1 -> x_0)-| | |   minReads=(Right 4)-| | |   mayRaise=[ExceptionFailure]-| | | pushValue 'a'-| | |   minReads=(Right 4)-| | |   mayRaise=[ExceptionFailure]-| | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | |   minReads=(Right 4)-| | |   mayRaise=[ExceptionFailure]-| | | read ((GHC.Classes.==) 'a')-| | |   minReads=(Right 4)-| | |   mayRaise=[ExceptionFailure]-| | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | |   minReads=(Right 3)-| | |   mayRaise=[ExceptionFailure]-| | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | |   minReads=(Right 3)-| | |   mayRaise=[ExceptionFailure]-| | | pushValue (GHC.Types.:)-| | |   minReads=(Right 3)-| | |   mayRaise=[ExceptionFailure]-| | | pushValue (\x_0 -> \x_1 -> x_0)-| | |   minReads=(Right 3)-| | |   mayRaise=[ExceptionFailure]-| | | pushValue 'b'-| | |   minReads=(Right 3)-| | |   mayRaise=[ExceptionFailure]-| | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | |   minReads=(Right 3)-| | |   mayRaise=[ExceptionFailure]-| | | read ((GHC.Classes.==) 'b')-| | |   minReads=(Right 3)-| | |   mayRaise=[ExceptionFailure]-| | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | |   minReads=(Right 2)-| | |   mayRaise=[ExceptionFailure]-| | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | |   minReads=(Right 2)-| | |   mayRaise=[ExceptionFailure]-| | | pushValue (GHC.Types.:)-| | |   minReads=(Right 2)-| | |   mayRaise=[ExceptionFailure]-| | | pushValue (\x_0 -> \x_1 -> x_0)-| | |   minReads=(Right 2)-| | |   mayRaise=[ExceptionFailure]-| | | pushValue 'c'-| | |   minReads=(Right 2)-| | |   mayRaise=[ExceptionFailure]-| | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | |   minReads=(Right 2)-| | |   mayRaise=[ExceptionFailure]-| | | read ((GHC.Classes.==) 'c')-| | |   minReads=(Right 2)-| | |   mayRaise=[ExceptionFailure]-| | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | |   minReads=(Right 1)-| | |   mayRaise=[ExceptionFailure]-| | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | |   minReads=(Right 1)-| | |   mayRaise=[ExceptionFailure]-| | | pushValue (GHC.Types.:)-| | |   minReads=(Right 1)-| | |   mayRaise=[ExceptionFailure]-| | | pushValue (\x_0 -> \x_1 -> x_0)-| | |   minReads=(Right 1)-| | |   mayRaise=[ExceptionFailure]-| | | pushValue 'd'-| | |   minReads=(Right 1)-| | |   mayRaise=[ExceptionFailure]-| | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | |   minReads=(Right 1)-| | |   mayRaise=[ExceptionFailure]-| | | read ((GHC.Classes.==) 'd')-| | |   minReads=(Right 1)-| | |   mayRaise=[ExceptionFailure]-| | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | |   minReads=(Right 0)-| | |   mayRaise=[]-| | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | |   minReads=(Right 0)-| | |   mayRaise=[]-| | | pushValue GHC.Types.[]-| | |   minReads=(Right 0)-| | |   mayRaise=[]-| | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | |   minReads=(Right 0)-| | |   mayRaise=[]-| | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | |   minReads=(Right 0)-| | |   mayRaise=[]-| | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | |   minReads=(Right 0)-| | |   mayRaise=[]-| | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | |   minReads=(Right 0)-| | |   mayRaise=[]-| | | commit ExceptionFailure-| | |   minReads=(Right 0)-| | |   mayRaise=[]-| | | ret-| | |   minReads=(Right 0)-| | |   mayRaise=[]-| | <ko>-| | | loadInput-| | |   minReads=(Left ExceptionFailure)-| | |   mayRaise=[ExceptionFailure]-| | | fail []-| | |   minReads=(Left ExceptionFailure)-| | |   mayRaise=[ExceptionFailure]-pushValue GHC.Show.show-  minReads=(Right 4)-  mayRaise=[ExceptionFailure]-pushValue (\x_0 -> \x_1 -> x_0)-  minReads=(Right 4)-  mayRaise=[ExceptionFailure]-pushValue (GHC.Types.:)-  minReads=(Right 4)-  mayRaise=[ExceptionFailure]-call <hidden>-  minReads=(Right 4)-  mayRaise=[ExceptionFailure]-lift2Value (\x_0 -> \x_1 -> x_0 x_1)-  minReads=(Right 0)-  mayRaise=[ExceptionFailure]-call <hidden>-  minReads=(Right 0)-  mayRaise=[ExceptionFailure]-pushValue GHC.Types.[]-  minReads=(Right 0)-  mayRaise=[ExceptionFailure]-lift2Value (\x_0 -> \x_1 -> x_0 x_1)-  minReads=(Right 0)-  mayRaise=[ExceptionFailure]-lift2Value (\x_0 -> \x_1 -> x_0 x_1)-  minReads=(Right 0)-  mayRaise=[ExceptionFailure]-lift2Value (\x_0 -> \x_1 -> x_0 x_1)-  minReads=(Right 0)-  mayRaise=[ExceptionFailure]-join <hidden>-  minReads=(Right 0)-  mayRaise=[]-| lift2Value (\x_0 -> \x_1 -> x_0 x_1)-|   minReads=(Right 0)-|   mayRaise=[]-| lift2Value (\x_0 -> \x_1 -> x_0 x_1)-|   minReads=(Right 0)-|   mayRaise=[]-| ret-|   minReads=(Right 0)-|   mayRaise=[]-catch ExceptionFailure-  minReads=(Right 0)-  mayRaise=[ExceptionFailure]-| <ok>-| | catch ExceptionFailure-| |   minReads=(Right 0)-| |   mayRaise=[]-| | | <ok>-| | | | pushInput-| | | |   minReads=(Left ExceptionFailure)-| | | |   mayRaise=[ExceptionFailure]-| | | | read ((\x_0 -> \x_1 -> x_0) GHC.Types.True)-| | | |   minReads=(Left ExceptionFailure)-| | | |   mayRaise=[ExceptionFailure]-| | | | popValue-| | | |   minReads=(Left ExceptionFailure)-| | | |   mayRaise=[ExceptionFailure]-| | | | commit ExceptionFailure-| | | |   minReads=(Left ExceptionFailure)-| | | |   mayRaise=[ExceptionFailure]-| | | | loadInput-| | | |   minReads=(Left ExceptionFailure)-| | | |   mayRaise=[ExceptionFailure]-| | | | fail []-| | | |   minReads=(Left ExceptionFailure)-| | | |   mayRaise=[ExceptionFailure]-| | | <ko>-| | | | loadInput-| | | |   minReads=(Right 0)-| | | |   mayRaise=[]-| | | | pushValue GHC.Tuple.()-| | | |   minReads=(Right 0)-| | | |   mayRaise=[]-| | | | commit ExceptionFailure-| | | |   minReads=(Right 0)-| | | |   mayRaise=[]-| | | | refJoin <hidden>-| | | |   minReads=(Right 0)-| | | |   mayRaise=[]-| <ko>-| | pushInput-| |   minReads=(Left ExceptionFailure)-| |   mayRaise=[ExceptionFailure]-| | lift2Value (\(Data.Text.Internal.Text _ i_0 _) (Data.Text.Internal.Text _-| |                                                                j_1-| |                                                                _) -> i_0 GHC.Classes.== j_1)-| |   minReads=(Left ExceptionFailure)-| |   mayRaise=[ExceptionFailure]-| | choicesBranch [\x_0 -> x_0]-| |   minReads=(Left ExceptionFailure)-| |   mayRaise=[ExceptionFailure]-| | | <branch>-| | | | fail [FailureEnd]-| | | |   minReads=(Left ExceptionFailure)-| | | |   mayRaise=[ExceptionFailure]-| | | <default>-| | | | fail []-| | | |   minReads=(Left ExceptionFailure)-| | | |   mayRaise=[ExceptionFailure]
− test/Golden/Machine/G6.expected.txt 
@@ -1,144 +0,0 @@-pushValue GHC.Show.show-  minReads=(Right 2)-  mayRaise=[ExceptionFailure]-join <hidden>-  minReads=(Right 0)-  mayRaise=[]-| lift2Value (\x_0 -> \x_1 -> x_0 x_1)-|   minReads=(Right 0)-|   mayRaise=[]-| ret-|   minReads=(Right 0)-|   mayRaise=[]-catch ExceptionFailure-  minReads=(Right 2)-  mayRaise=[ExceptionFailure]-| <ok>-| | pushValue (GHC.Types.:)-| |   minReads=(Right 2)-| |   mayRaise=[ExceptionFailure]-| | pushValue (\x_0 -> \x_1 -> x_0)-| |   minReads=(Right 2)-| |   mayRaise=[ExceptionFailure]-| | pushValue 'a'-| |   minReads=(Right 2)-| |   mayRaise=[ExceptionFailure]-| | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| |   minReads=(Right 2)-| |   mayRaise=[ExceptionFailure]-| | read ((GHC.Classes.==) 'a')-| |   minReads=(Right 2)-| |   mayRaise=[ExceptionFailure]-| | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| |   minReads=(Right 1)-| |   mayRaise=[ExceptionFailure]-| | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| |   minReads=(Right 1)-| |   mayRaise=[ExceptionFailure]-| | pushValue (GHC.Types.:)-| |   minReads=(Right 1)-| |   mayRaise=[ExceptionFailure]-| | pushValue (\x_0 -> \x_1 -> x_0)-| |   minReads=(Right 1)-| |   mayRaise=[ExceptionFailure]-| | pushValue 'a'-| |   minReads=(Right 1)-| |   mayRaise=[ExceptionFailure]-| | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| |   minReads=(Right 1)-| |   mayRaise=[ExceptionFailure]-| | read ((GHC.Classes.==) 'a')-| |   minReads=(Right 1)-| |   mayRaise=[ExceptionFailure]-| | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| |   minReads=(Right 0)-| |   mayRaise=[]-| | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| |   minReads=(Right 0)-| |   mayRaise=[]-| | pushValue GHC.Types.[]-| |   minReads=(Right 0)-| |   mayRaise=[]-| | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| |   minReads=(Right 0)-| |   mayRaise=[]-| | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| |   minReads=(Right 0)-| |   mayRaise=[]-| | commit ExceptionFailure-| |   minReads=(Right 0)-| |   mayRaise=[]-| | refJoin <hidden>-| |   minReads=(Right 0)-| |   mayRaise=[]-| <ko>-| | pushInput-| |   minReads=(Right 2)-| |   mayRaise=[ExceptionFailure]-| | lift2Value (\(Data.Text.Internal.Text _ i_0 _) (Data.Text.Internal.Text _-| |                                                                j_1-| |                                                                _) -> i_0 GHC.Classes.== j_1)-| |   minReads=(Right 2)-| |   mayRaise=[ExceptionFailure]-| | choicesBranch [\x_0 -> x_0]-| |   minReads=(Right 2)-| |   mayRaise=[ExceptionFailure]-| | | <branch>-| | | | pushValue (GHC.Types.:)-| | | |   minReads=(Right 2)-| | | |   mayRaise=[ExceptionFailure]-| | | | pushValue (\x_0 -> \x_1 -> x_0)-| | | |   minReads=(Right 2)-| | | |   mayRaise=[ExceptionFailure]-| | | | pushValue 'a'-| | | |   minReads=(Right 2)-| | | |   mayRaise=[ExceptionFailure]-| | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | |   minReads=(Right 2)-| | | |   mayRaise=[ExceptionFailure]-| | | | read ((GHC.Classes.==) 'a')-| | | |   minReads=(Right 2)-| | | |   mayRaise=[ExceptionFailure]-| | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | |   minReads=(Right 1)-| | | |   mayRaise=[ExceptionFailure]-| | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | |   minReads=(Right 1)-| | | |   mayRaise=[ExceptionFailure]-| | | | pushValue (GHC.Types.:)-| | | |   minReads=(Right 1)-| | | |   mayRaise=[ExceptionFailure]-| | | | pushValue (\x_0 -> \x_1 -> x_0)-| | | |   minReads=(Right 1)-| | | |   mayRaise=[ExceptionFailure]-| | | | pushValue 'b'-| | | |   minReads=(Right 1)-| | | |   mayRaise=[ExceptionFailure]-| | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | |   minReads=(Right 1)-| | | |   mayRaise=[ExceptionFailure]-| | | | read ((GHC.Classes.==) 'b')-| | | |   minReads=(Right 1)-| | | |   mayRaise=[ExceptionFailure]-| | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | |   minReads=(Right 0)-| | | |   mayRaise=[]-| | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | |   minReads=(Right 0)-| | | |   mayRaise=[]-| | | | pushValue GHC.Types.[]-| | | |   minReads=(Right 0)-| | | |   mayRaise=[]-| | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | |   minReads=(Right 0)-| | | |   mayRaise=[]-| | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | |   minReads=(Right 0)-| | | |   mayRaise=[]-| | | | refJoin <hidden>-| | | |   minReads=(Right 0)-| | | |   mayRaise=[]-| | | <default>-| | | | fail []-| | | |   minReads=(Left ExceptionFailure)-| | | |   mayRaise=[ExceptionFailure]
− test/Golden/Machine/G7.expected.txt 
@@ -1,172 +0,0 @@-pushValue GHC.Show.show-  minReads=(Right 2)-  mayRaise=[ExceptionFailure]-join <hidden>-  minReads=(Right 0)-  mayRaise=[]-| lift2Value (\x_0 -> \x_1 -> x_0 x_1)-|   minReads=(Right 0)-|   mayRaise=[]-| ret-|   minReads=(Right 0)-|   mayRaise=[]-catch ExceptionFailure-  minReads=(Right 2)-  mayRaise=[ExceptionFailure]-| <ok>-| | catch ExceptionFailure-| |   minReads=(Right 2)-| |   mayRaise=[ExceptionFailure]-| | | <ok>-| | | | pushValue (GHC.Types.:)-| | | |   minReads=(Right 2)-| | | |   mayRaise=[ExceptionFailure]-| | | | pushValue (\x_0 -> \x_1 -> x_0)-| | | |   minReads=(Right 2)-| | | |   mayRaise=[ExceptionFailure]-| | | | pushValue 'a'-| | | |   minReads=(Right 2)-| | | |   mayRaise=[ExceptionFailure]-| | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | |   minReads=(Right 2)-| | | |   mayRaise=[ExceptionFailure]-| | | | read ((GHC.Classes.==) 'a')-| | | |   minReads=(Right 2)-| | | |   mayRaise=[ExceptionFailure]-| | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | |   minReads=(Right 1)-| | | |   mayRaise=[ExceptionFailure]-| | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | |   minReads=(Right 1)-| | | |   mayRaise=[ExceptionFailure]-| | | | pushValue (GHC.Types.:)-| | | |   minReads=(Right 1)-| | | |   mayRaise=[ExceptionFailure]-| | | | pushValue (\x_0 -> \x_1 -> x_0)-| | | |   minReads=(Right 1)-| | | |   mayRaise=[ExceptionFailure]-| | | | pushValue 'a'-| | | |   minReads=(Right 1)-| | | |   mayRaise=[ExceptionFailure]-| | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | |   minReads=(Right 1)-| | | |   mayRaise=[ExceptionFailure]-| | | | read ((GHC.Classes.==) 'a')-| | | |   minReads=(Right 1)-| | | |   mayRaise=[ExceptionFailure]-| | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | |   minReads=(Right 0)-| | | |   mayRaise=[]-| | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | |   minReads=(Right 0)-| | | |   mayRaise=[]-| | | | pushValue GHC.Types.[]-| | | |   minReads=(Right 0)-| | | |   mayRaise=[]-| | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | |   minReads=(Right 0)-| | | |   mayRaise=[]-| | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | |   minReads=(Right 0)-| | | |   mayRaise=[]-| | | | commit ExceptionFailure-| | | |   minReads=(Right 0)-| | | |   mayRaise=[]-| | | | commit ExceptionFailure-| | | |   minReads=(Right 0)-| | | |   mayRaise=[]-| | | | refJoin <hidden>-| | | |   minReads=(Right 0)-| | | |   mayRaise=[]-| | | <ko>-| | | | loadInput-| | | |   minReads=(Left ExceptionFailure)-| | | |   mayRaise=[ExceptionFailure]-| | | | fail []-| | | |   minReads=(Left ExceptionFailure)-| | | |   mayRaise=[ExceptionFailure]-| <ko>-| | pushInput-| |   minReads=(Right 2)-| |   mayRaise=[ExceptionFailure]-| | lift2Value (\(Data.Text.Internal.Text _ i_0 _) (Data.Text.Internal.Text _-| |                                                                j_1-| |                                                                _) -> i_0 GHC.Classes.== j_1)-| |   minReads=(Right 2)-| |   mayRaise=[ExceptionFailure]-| | choicesBranch [\x_0 -> x_0]-| |   minReads=(Right 2)-| |   mayRaise=[ExceptionFailure]-| | | <branch>-| | | | catch ExceptionFailure-| | | |   minReads=(Right 2)-| | | |   mayRaise=[ExceptionFailure]-| | | | | <ok>-| | | | | | pushValue (GHC.Types.:)-| | | | | |   minReads=(Right 2)-| | | | | |   mayRaise=[ExceptionFailure]-| | | | | | pushValue (\x_0 -> \x_1 -> x_0)-| | | | | |   minReads=(Right 2)-| | | | | |   mayRaise=[ExceptionFailure]-| | | | | | pushValue 'a'-| | | | | |   minReads=(Right 2)-| | | | | |   mayRaise=[ExceptionFailure]-| | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | | |   minReads=(Right 2)-| | | | | |   mayRaise=[ExceptionFailure]-| | | | | | read ((GHC.Classes.==) 'a')-| | | | | |   minReads=(Right 2)-| | | | | |   mayRaise=[ExceptionFailure]-| | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | | |   minReads=(Right 1)-| | | | | |   mayRaise=[ExceptionFailure]-| | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | | |   minReads=(Right 1)-| | | | | |   mayRaise=[ExceptionFailure]-| | | | | | pushValue (GHC.Types.:)-| | | | | |   minReads=(Right 1)-| | | | | |   mayRaise=[ExceptionFailure]-| | | | | | pushValue (\x_0 -> \x_1 -> x_0)-| | | | | |   minReads=(Right 1)-| | | | | |   mayRaise=[ExceptionFailure]-| | | | | | pushValue 'b'-| | | | | |   minReads=(Right 1)-| | | | | |   mayRaise=[ExceptionFailure]-| | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | | |   minReads=(Right 1)-| | | | | |   mayRaise=[ExceptionFailure]-| | | | | | read ((GHC.Classes.==) 'b')-| | | | | |   minReads=(Right 1)-| | | | | |   mayRaise=[ExceptionFailure]-| | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | | |   minReads=(Right 0)-| | | | | |   mayRaise=[]-| | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | | |   minReads=(Right 0)-| | | | | |   mayRaise=[]-| | | | | | pushValue GHC.Types.[]-| | | | | |   minReads=(Right 0)-| | | | | |   mayRaise=[]-| | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | | |   minReads=(Right 0)-| | | | | |   mayRaise=[]-| | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | | | | |   minReads=(Right 0)-| | | | | |   mayRaise=[]-| | | | | | commit ExceptionFailure-| | | | | |   minReads=(Right 0)-| | | | | |   mayRaise=[]-| | | | | | refJoin <hidden>-| | | | | |   minReads=(Right 0)-| | | | | |   mayRaise=[]-| | | | | <ko>-| | | | | | loadInput-| | | | | |   minReads=(Left ExceptionFailure)-| | | | | |   mayRaise=[ExceptionFailure]-| | | | | | fail []-| | | | | |   minReads=(Left ExceptionFailure)-| | | | | |   mayRaise=[ExceptionFailure]-| | | <default>-| | | | fail []-| | | |   minReads=(Left ExceptionFailure)-| | | |   mayRaise=[ExceptionFailure]
− test/Golden/Machine/G8.expected.txt 
@@ -1,158 +0,0 @@-let <hidden>-  minReads=(Right 0)-  mayRaise=[ExceptionFailure]-| catch ExceptionFailure-|   minReads=(Right 0)-|   mayRaise=[ExceptionFailure]-| | <ok>-| | | pushValue (\x_0 -> \x_1 -> \x_2 -> x_0 (x_1 x_2))-| | |   minReads=(Right 1)-| | |   mayRaise=[ExceptionFailure]-| | | pushValue (GHC.Types.:)-| | |   minReads=(Right 1)-| | |   mayRaise=[ExceptionFailure]-| | | pushValue (\x_0 -> \x_1 -> x_0)-| | |   minReads=(Right 1)-| | |   mayRaise=[ExceptionFailure]-| | | pushValue 'r'-| | |   minReads=(Right 1)-| | |   mayRaise=[ExceptionFailure]-| | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | |   minReads=(Right 1)-| | |   mayRaise=[ExceptionFailure]-| | | read ((GHC.Classes.==) 'r')-| | |   minReads=(Right 1)-| | |   mayRaise=[ExceptionFailure]-| | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | |   minReads=(Right 0)-| | |   mayRaise=[ExceptionFailure]-| | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | |   minReads=(Right 0)-| | |   mayRaise=[ExceptionFailure]-| | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | |   minReads=(Right 0)-| | |   mayRaise=[ExceptionFailure]-| | | call <hidden>-| | |   minReads=(Right 0)-| | |   mayRaise=[ExceptionFailure]-| | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)-| | |   minReads=(Right 0)-| | |   mayRaise=[]-| | | commit ExceptionFailure-| | |   minReads=(Right 0)-| | |   mayRaise=[]-| | | ret-| | |   minReads=(Right 0)-| | |   mayRaise=[]-| | <ko>-| | | pushInput-| | |   minReads=(Right 0)-| | |   mayRaise=[ExceptionFailure]-| | | lift2Value (\(Data.Text.Internal.Text _ i_0 _) (Data.Text.Internal.Text _-| | |                                                                j_1-| | |                                                                _) -> i_0 GHC.Classes.== j_1)-| | |   minReads=(Right 0)-| | |   mayRaise=[ExceptionFailure]-| | | choicesBranch [\x_0 -> x_0]-| | |   minReads=(Right 0)-| | |   mayRaise=[ExceptionFailure]-| | | | <branch>-| | | | | pushValue (\x_0 -> x_0)-| | | | |   minReads=(Right 0)-| | | | |   mayRaise=[]-| | | | | ret-| | | | |   minReads=(Right 0)-| | | | |   mayRaise=[]-| | | | <default>-| | | | | fail []-| | | | |   minReads=(Left ExceptionFailure)-| | | | |   mayRaise=[ExceptionFailure]-pushValue GHC.Show.show-  minReads=(Right 0)-  mayRaise=[ExceptionFailure]-pushValue (\x_0 -> \x_1 -> x_0)-  minReads=(Right 0)-  mayRaise=[ExceptionFailure]-call <hidden>-  minReads=(Right 0)-  mayRaise=[ExceptionFailure]-pushValue GHC.Types.[]-  minReads=(Right 0)-  mayRaise=[ExceptionFailure]-lift2Value (\x_0 -> \x_1 -> x_0 x_1)-  minReads=(Right 0)-  mayRaise=[ExceptionFailure]-lift2Value (\x_0 -> \x_1 -> x_0 x_1)-  minReads=(Right 0)-  mayRaise=[ExceptionFailure]-join <hidden>-  minReads=(Right 0)-  mayRaise=[]-| lift2Value (\x_0 -> \x_1 -> x_0 x_1)-|   minReads=(Right 0)-|   mayRaise=[]-| lift2Value (\x_0 -> \x_1 -> x_0 x_1)-|   minReads=(Right 0)-|   mayRaise=[]-| ret-|   minReads=(Right 0)-|   mayRaise=[]-catch ExceptionFailure-  minReads=(Right 0)-  mayRaise=[ExceptionFailure]-| <ok>-| | catch ExceptionFailure-| |   minReads=(Right 0)-| |   mayRaise=[]-| | | <ok>-| | | | pushInput-| | | |   minReads=(Left ExceptionFailure)-| | | |   mayRaise=[ExceptionFailure]-| | | | read ((\x_0 -> \x_1 -> x_0) GHC.Types.True)-| | | |   minReads=(Left ExceptionFailure)-| | | |   mayRaise=[ExceptionFailure]-| | | | popValue-| | | |   minReads=(Left ExceptionFailure)-| | | |   mayRaise=[ExceptionFailure]-| | | | commit ExceptionFailure-| | | |   minReads=(Left ExceptionFailure)-| | | |   mayRaise=[ExceptionFailure]-| | | | loadInput-| | | |   minReads=(Left ExceptionFailure)-| | | |   mayRaise=[ExceptionFailure]-| | | | fail []-| | | |   minReads=(Left ExceptionFailure)-| | | |   mayRaise=[ExceptionFailure]-| | | <ko>-| | | | loadInput-| | | |   minReads=(Right 0)-| | | |   mayRaise=[]-| | | | pushValue GHC.Tuple.()-| | | |   minReads=(Right 0)-| | | |   mayRaise=[]-| | | | commit ExceptionFailure-| | | |   minReads=(Right 0)-| | | |   mayRaise=[]-| | | | refJoin <hidden>-| | | |   minReads=(Right 0)-| | | |   mayRaise=[]-| <ko>-| | pushInput-| |   minReads=(Left ExceptionFailure)-| |   mayRaise=[ExceptionFailure]-| | lift2Value (\(Data.Text.Internal.Text _ i_0 _) (Data.Text.Internal.Text _-| |                                                                j_1-| |                                                                _) -> i_0 GHC.Classes.== j_1)-| |   minReads=(Left ExceptionFailure)-| |   mayRaise=[ExceptionFailure]-| | choicesBranch [\x_0 -> x_0]-| |   minReads=(Left ExceptionFailure)-| |   mayRaise=[ExceptionFailure]-| | | <branch>-| | | | fail [FailureEnd]-| | | |   minReads=(Left ExceptionFailure)-| | | |   mayRaise=[ExceptionFailure]-| | | <default>-| | | | fail []-| | | |   minReads=(Left ExceptionFailure)-| | | |   mayRaise=[ExceptionFailure]
− test/Golden/Machine/G9.expected.txt 
@@ -1,71 +0,0 @@-pushValue GHC.Show.show-  minReads=(Right 0)-  mayRaise=[ExceptionFailure]-join <hidden>-  minReads=(Right 0)-  mayRaise=[]-| lift2Value (\x_0 -> \x_1 -> x_0 x_1)-|   minReads=(Right 0)-|   mayRaise=[]-| ret-|   minReads=(Right 0)-|   mayRaise=[]-catch ExceptionFailure-  minReads=(Right 0)-  mayRaise=[ExceptionFailure]-| <ok>-| | catch ExceptionFailure-| |   minReads=(Right 0)-| |   mayRaise=[]-| | | <ok>-| | | | pushInput-| | | |   minReads=(Left ExceptionFailure)-| | | |   mayRaise=[ExceptionFailure]-| | | | read ((\x_0 -> \x_1 -> x_0) GHC.Types.True)-| | | |   minReads=(Left ExceptionFailure)-| | | |   mayRaise=[ExceptionFailure]-| | | | popValue-| | | |   minReads=(Left ExceptionFailure)-| | | |   mayRaise=[ExceptionFailure]-| | | | commit ExceptionFailure-| | | |   minReads=(Left ExceptionFailure)-| | | |   mayRaise=[ExceptionFailure]-| | | | loadInput-| | | |   minReads=(Left ExceptionFailure)-| | | |   mayRaise=[ExceptionFailure]-| | | | fail []-| | | |   minReads=(Left ExceptionFailure)-| | | |   mayRaise=[ExceptionFailure]-| | | <ko>-| | | | loadInput-| | | |   minReads=(Right 0)-| | | |   mayRaise=[]-| | | | pushValue GHC.Tuple.()-| | | |   minReads=(Right 0)-| | | |   mayRaise=[]-| | | | commit ExceptionFailure-| | | |   minReads=(Right 0)-| | | |   mayRaise=[]-| | | | refJoin <hidden>-| | | |   minReads=(Right 0)-| | | |   mayRaise=[]-| <ko>-| | pushInput-| |   minReads=(Left ExceptionFailure)-| |   mayRaise=[ExceptionFailure]-| | lift2Value (\(Data.Text.Internal.Text _ i_0 _) (Data.Text.Internal.Text _-| |                                                                j_1-| |                                                                _) -> i_0 GHC.Classes.== j_1)-| |   minReads=(Left ExceptionFailure)-| |   mayRaise=[ExceptionFailure]-| | choicesBranch [\x_0 -> x_0]-| |   minReads=(Left ExceptionFailure)-| |   mayRaise=[ExceptionFailure]-| | | <branch>-| | | | fail [FailureEnd]-| | | |   minReads=(Left ExceptionFailure)-| | | |   mayRaise=[ExceptionFailure]-| | | <default>-| | | | fail []-| | | |   minReads=(Left ExceptionFailure)-| | | |   mayRaise=[ExceptionFailure]
− test/Golden/Parser.hs 
@@ -1,86 +0,0 @@-{-# LANGUAGE DataKinds #-} -- For using P.viewGrammar-{-# LANGUAGE FlexibleContexts #-} -- For using P.Grammar Char-{-# LANGUAGE Rank2Types #-}-{-# LANGUAGE TypeApplications #-}--- For TH splices-{-# LANGUAGE TemplateHaskell #-}-{-# LANGUAGE Rank2Types #-}-{-# LANGUAGE ScopedTypeVariables #-}-{-# LANGUAGE UnboxedTuples #-}-{-# OPTIONS_GHC -Wno-missing-signatures #-}-{-# OPTIONS_GHC -Wno-unused-local-binds #-}-{-# OPTIONS_GHC -Wno-unused-matches #-}-module Golden.Parser where--import Control.Monad (Monad(..))-import Data.Either (Either(..))-import Data.Function (($))-import Data.Functor ((<$>))-import Data.Int (Int)-import Data.Semigroup (Semigroup(..))-import Data.String (String, IsString(..))-import Data.Text (Text)-import Data.Text.IO (readFile)-import System.FilePath ((<.>), (</>), dropExtensions, takeBaseName)-import System.IO.Unsafe (unsafePerformIO)-import Test.Tasty-import Test.Tasty.Golden-import Text.Show (Show(..))-import qualified Control.Exception as IO-import qualified Data.List as List-import qualified System.Directory as IO-import qualified System.IO.Error as IO-import qualified Language.Haskell.TH as TH--import qualified Symantic.Parser as P-import Golden.Utils-import Golden.Splice--goldens :: TestTree-goldens = testGroup "Parser" $-  (\f -> List.zipWith f parsers [1::Int ..]) $ \p g ->-  -- Collect the existing files: test/Golden/Parser/G*.input.txt-  let parserDir = getGoldenDir $ "Parser/G"<>show g in-  let inputs =-        ((parserDir </>) <$>) $-        List.sort $-        List.filter (List.isSuffixOf ".input.txt") $-        unsafePerformIO $-          IO.catchIOError-            (IO.listDirectory parserDir)-            (\exn ->-              if IO.isDoesNotExistError exn-              then return []-              else IO.throwIO exn-            ) in-  testGroup ("G"<>show g) $ (<$> inputs) $ \inp ->-    goldenVsStringDiff (takeBaseName (dropExtensions inp)) goldenDiff-      (dropExtensions inp<.>"expected.txt") $ do-      input <- readFile inp-      return $ fromString $-        case p input of-          Left err -> show err-          Right a -> a--parsers :: [Text -> Either (P.ParsingError Text) String]-parsers =-  [ p1, p2, p3, p4, p5, p6, p7, p8, p9-  , p10, p11, p12, p13, p14, p15, p16-  ]--p1 = $$(TH.Code $ TH.runIO s1)-p2 = $$(TH.Code $ TH.runIO s2)-p3 = $$(TH.Code $ TH.runIO s3)-p4 = $$(TH.Code $ TH.runIO s4)-p5 = $$(TH.Code $ TH.runIO s5)-p6 = $$(TH.Code $ TH.runIO s6)-p7 = $$(TH.Code $ TH.runIO s7)-p8 = $$(TH.Code $ TH.runIO s8)-p9 = $$(TH.Code $ TH.runIO s9)-p10 = $$(TH.Code $ TH.runIO s10)-p11 = $$(TH.Code $ TH.runIO s11)-p12 = $$(TH.Code $ TH.runIO s12)-p13 = $$(TH.Code $ TH.runIO s13)-p14 = $$(TH.Code $ TH.runIO s14)-p15 = $$(TH.Code $ TH.runIO s15)-p16 = $$(TH.Code $ TH.runIO s16)
− test/Golden/Parser/G1/P1.expected.txt 
@@ -1,1 +0,0 @@-'a'
− test/Golden/Parser/G1/P1.input.txt 
@@ -1,1 +0,0 @@-a
− test/Golden/Parser/G10/P1.expected.txt 
@@ -1,1 +0,0 @@-ParsingErrorStandard {parsingErrorOffset = 0, parsingErrorException = ExceptionFailure, parsingErrorUnexpected = Just 'c', parsingErrorExpecting = fromList [FailureToken 'a',FailureToken 'b']}
− test/Golden/Parser/G10/P1.input.txt 
@@ -1,1 +0,0 @@-c
− test/Golden/Parser/G11/P1.expected.txt 
@@ -1,1 +0,0 @@-ParsingErrorStandard {parsingErrorOffset = 4, parsingErrorException = ExceptionFailure, parsingErrorUnexpected = Just 'c', parsingErrorExpecting = fromList [FailureToken 'a',FailureToken 'b']}
− test/Golden/Parser/G11/P1.input.txt 
@@ -1,1 +0,0 @@-aaaac
− test/Golden/Parser/G12/P1.expected.txt 
@@ -1,1 +0,0 @@-"baacbccbaa"
− test/Golden/Parser/G12/P1.input.txt 
@@ -1,1 +0,0 @@-baacbccbaa
− test/Golden/Parser/G13/P1.expected.txt 
@@ -1,1 +0,0 @@-[Increment,Increment,Increment,Increment,Increment,Increment,Increment,Increment,Increment,Increment,Loop [Forward,Increment,Increment,Increment,Increment,Increment,Increment,Increment,Forward,Increment,Increment,Increment,Increment,Increment,Increment,Increment,Increment,Increment,Increment,Forward,Increment,Increment,Increment,Forward,Increment,Backward,Backward,Backward,Backward,Decrement],Forward,Increment,Increment,Output,Forward,Increment,Output,Increment,Increment,Increment,Increment,Increment,Increment,Increment,Output,Output,Increment,Increment,Increment,Output,Forward,Increment,Increment,Output,Backward,Backward,Increment,Increment,Increment,Increment,Increment,Increment,Increment,Increment,Increment,Increment,Increment,Increment,Increment,Increment,Increment,Output,Forward,Output,Increment,Increment,Increment,Output,Decrement,Decrement,Decrement,Decrement,Decrement,Decrement,Output,Decrement,Decrement,Decrement,Decrement,Decrement,Decrement,Decrement,Decrement,Output,Forward,Increment,Output,Forward,Output]
− test/Golden/Parser/G13/P1.input.txt 
@@ -1,1 +0,0 @@-++++++++++[>+++++++>++++++++++>+++>+<<<<-]>++.>+.+++++++..+++.>++.<<+++++++++++++++.>.+++.------.--------.>+.>.
− test/Golden/Parser/G13/P2.expected.txt 
@@ -1,1 +0,0 @@-[Loop [Decrement]]
− test/Golden/Parser/G13/P2.input.txt 
@@ -1,3 +0,0 @@-[     boucle--     enlever 1 à la case courante-]     jusqu'à ce que la case soit à zéro
− test/Golden/Parser/G2/P1.expected.txt 
@@ -1,1 +0,0 @@-"abc"
− test/Golden/Parser/G2/P1.input.txt 
@@ -1,1 +0,0 @@-abc
− test/Golden/Parser/G2/P2.expected.txt 
@@ -1,1 +0,0 @@-ParsingErrorStandard {parsingErrorOffset = 0, parsingErrorException = ExceptionFailure, parsingErrorUnexpected = Just 'a', parsingErrorExpecting = fromList [FailureHorizon 3]}
− test/Golden/Parser/G2/P2.input.txt 
@@ -1,1 +0,0 @@-ab
− test/Golden/Parser/G3/P1.expected.txt 
@@ -1,1 +0,0 @@-"aaaaa"
− test/Golden/Parser/G3/P1.input.txt 
@@ -1,1 +0,0 @@-aaaaa
− test/Golden/Parser/G4/P1.expected.txt 
@@ -1,1 +0,0 @@-["abcd","abcd","abcd"]
− test/Golden/Parser/G4/P1.input.txt 
@@ -1,1 +0,0 @@-abcdabcdabcd
− test/Golden/Parser/G4/P2.expected.txt 
@@ -1,1 +0,0 @@-["abcd","abcd","abcd"]
− test/Golden/Parser/G4/P2.input.txt 
@@ -1,1 +0,0 @@-abcdabcdabcde
− test/Golden/Parser/G4/P3.expected.txt 
@@ -1,1 +0,0 @@-["abcd","abcd","abcd"]
− test/Golden/Parser/G4/P3.input.txt 
@@ -1,1 +0,0 @@-abcdabcdabcdefgh
− test/Golden/Parser/G5/P1.expected.txt 
@@ -1,1 +0,0 @@-ParsingErrorStandard {parsingErrorOffset = 0, parsingErrorException = ExceptionFailure, parsingErrorUnexpected = Just 'a', parsingErrorExpecting = fromList [FailureHorizon 4]}
− test/Golden/Parser/G5/P1.input.txt 
@@ -1,1 +0,0 @@-abc
− test/Golden/Parser/G5/P2.expected.txt 
@@ -1,1 +0,0 @@-ParsingErrorStandard {parsingErrorOffset = 4, parsingErrorException = ExceptionFailure, parsingErrorUnexpected = Just 'a', parsingErrorExpecting = fromList [FailureEnd,FailureHorizon 4]}
− test/Golden/Parser/G5/P2.input.txt 
@@ -1,1 +0,0 @@-abcdabc
− test/Golden/Parser/G5/P3.expected.txt 
@@ -1,1 +0,0 @@-ParsingErrorStandard {parsingErrorOffset = 4, parsingErrorException = ExceptionFailure, parsingErrorUnexpected = Just 'e', parsingErrorExpecting = fromList [FailureEnd,FailureToken 'a']}
− test/Golden/Parser/G5/P3.input.txt 
@@ -1,1 +0,0 @@-abcdefgh
− test/Golden/Parser/G6/P1.expected.txt 
@@ -1,1 +0,0 @@-ParsingErrorStandard {parsingErrorOffset = 1, parsingErrorException = ExceptionFailure, parsingErrorUnexpected = Just 'b', parsingErrorExpecting = fromList [FailureToken 'a']}
− test/Golden/Parser/G6/P1.input.txt 
@@ -1,1 +0,0 @@-ab
− test/Golden/Parser/G7/P1.expected.txt 
@@ -1,1 +0,0 @@-"ab"
− test/Golden/Parser/G7/P1.input.txt 
@@ -1,1 +0,0 @@-ab
− test/Golden/Parser/G7/P2.expected.txt 
@@ -1,1 +0,0 @@-"aa"
− test/Golden/Parser/G7/P2.input.txt 
@@ -1,1 +0,0 @@-aa
− test/Golden/Parser/G8/P1.expected.txt 
@@ -1,1 +0,0 @@-ParsingErrorStandard {parsingErrorOffset = 3, parsingErrorException = ExceptionFailure, parsingErrorUnexpected = Just 'a', parsingErrorExpecting = fromList [FailureEnd,FailureToken 'r']}
− test/Golden/Parser/G8/P1.input.txt 
@@ -1,1 +0,0 @@-rrra
− test/Golden/Parser/G9/P1.expected.txt 
@@ -1,1 +0,0 @@-()
− test/Golden/Parser/G9/P1.input.txt 
− test/Golden/Parser/G9/P2.expected.txt 
@@ -1,1 +0,0 @@-ParsingErrorStandard {parsingErrorOffset = 0, parsingErrorException = ExceptionFailure, parsingErrorUnexpected = Just 'a', parsingErrorExpecting = fromList [FailureEnd]}
− test/Golden/Parser/G9/P2.input.txt 
@@ -1,1 +0,0 @@-a
− test/Golden/Parser/left-right.txt 
@@ -1,1 +0,0 @@-aa
− test/Golden/Splice.hs 
@@ -1,49 +0,0 @@-{-# OPTIONS_GHC -Wno-missing-signatures #-}-{-# OPTIONS_GHC -Wno-incomplete-uni-patterns #-}-module Golden.Splice where--import Data.Either (Either(..))-import Data.Function (($))-import Data.Functor ((<$>))-import Data.Int (Int)-import Data.List ((++))-import Data.String (String, IsString(..))-import Data.Text (Text)-import Symantic.Parser (ParsingError, optimizeMachine, generateCode)-import System.FilePath (dropExtensions, takeBaseName, (</>), (<.>))-import System.IO (IO)-import Test.Tasty-import Test.Tasty.Golden (goldenVsStringDiff)-import Text.Show (Show(..))-import qualified Data.List as List-import qualified Language.Haskell.TH as TH-import qualified Language.Haskell.TH.HideName as TH-import qualified System.Process as Process--import Golden.Utils-import qualified Grammar--goldens :: TestTree-goldens = testGroup "Splice"-  [ let spliceFile = getGoldenDir $ "Splice/"</>"G"++show g<.>"expected"<.>"txt" in-    goldenVsStringDiff (takeBaseName (dropExtensions spliceFile)) goldenDiff spliceFile $ do-      tExp <- splice-      fromString <$> Process.readProcess "ormolu"-        [ "-o", "-XBangPatterns"-        , "-o", "-XMagicHash"-        , "-o", "-XTypeApplications"-        , "-o", "-XUnboxedTuples"-        ]-        (show (TH.ppr (TH.hideName (TH.unType tExp))))-  | (g, splice) <- List.zip [1::Int ..] splices-  ]--splices :: [IO (TH.TExp (Text -> Either (ParsingError Text) String))]-splices = (<$> Grammar.grammars) $ \g -> TH.runQ $ do-  TH.runIO resetTHNameCounter-  mach <- TH.runIO $ optimizeMachine g-  TH.examineCode $ generateCode mach--[ s1,s2,s3,s4,s5,s6,s7,s8,s9- ,s10,s11,s12,s13,s14,s15,s16- ] = splices
− test/Golden/Splice/G1.expected.txt 
@@ -1,132 +0,0 @@-\(input :: inp) ->-  let !(#-         init,-         readMore,-         readNext-         #) =-          let _ = "cursorOf"-           in let next-                    ( t@( Data.Text.Internal.Text-                            arr-                            off-                            unconsumed-                          )-                      ) =-                      let !( Data.Text.Unsafe.Iter-                               c-                               d-                             ) = Data.Text.Unsafe.iter t 0-                       in (#-                            c,-                            Data.Text.Internal.Text arr (off GHC.Num.+ d) (unconsumed GHC.Num.- d)-                          #)-                  more-                    ( Data.Text.Internal.Text-                        _-                        _-                        unconsumed-                      ) = unconsumed GHC.Classes.> 0-               in (# input, more, next #)-      finalRet = \_farInp _farExp v _inp -> Data.Either.Right v-      finalRaise ::-        forall b.-        Symantic.Parser.Machine.Generate.Catcher-          inp-          b = \(!exn) _failInp (!farInp) (!farExp) ->-          Data.Either.Left-            Symantic.Parser.Machine.Generate.ParsingError-              { Symantic.Parser.Machine.Generate.parsingErrorOffset = Symantic.Parser.Machine.Input.offset farInp,-                Symantic.Parser.Machine.Generate.parsingErrorException = exn,-                Symantic.Parser.Machine.Generate.parsingErrorUnexpected =-                  if readMore farInp-                    then-                      GHC.Maybe.Just-                        ( let (#-                                c,-                                _-                                #) = readNext farInp-                           in c-                        )-                    else GHC.Maybe.Nothing,-                Symantic.Parser.Machine.Generate.parsingErrorExpecting = farExp-              }-   in let inputToken = Data.Proxy.Proxy :: Data.Proxy.Proxy (Symantic.Parser.Machine.Input.InputToken inp)-       in let-           in let readFail = finalRaise-               in if readMore init-                    then-                      let !(# c, cs #) = readNext init-                       in if (GHC.Classes.==) 'a' c-                            then-                              let _ = "resume"-                               in finalRet-                                    init-                                    Data.Set.Internal.empty-                                    ( let _ = "resume.genCode"-                                       in GHC.Show.show 'a'-                                    )-                                    cs-                            else-                              let _ = "checkToken.else"-                               in let failExp =-                                        Data.Set.Internal.Bin-                                          1-                                          ( Symantic.Parser.Grammar.Combinators.SomeFailure-                                              ( case inputToken of-                                                  (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken 'a'-                                              )-                                          )-                                          Data.Set.Internal.Tip-                                          Data.Set.Internal.Tip-                                   in let (#-                                            farInp,-                                            farExp-                                            #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init init of-                                              GHC.Types.LT ->-                                                (#-                                                  init,-                                                  failExp-                                                #)-                                              GHC.Types.EQ ->-                                                (#-                                                  init,-                                                  failExp GHC.Base.<> Data.Set.Internal.empty-                                                #)-                                              GHC.Types.GT ->-                                                (#-                                                  init,-                                                  Data.Set.Internal.empty-                                                #)-                                       in finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure init farInp farExp-                    else-                      let _ = "checkHorizon.else"-                       in let failExp =-                                Data.Set.Internal.Bin-                                  1-                                  ( Symantic.Parser.Grammar.Combinators.SomeFailure-                                      ( case inputToken of-                                          (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureHorizon @tok' 1-                                      )-                                  )-                                  Data.Set.Internal.Tip-                                  Data.Set.Internal.Tip-                           in let (#-                                    farInp,-                                    farExp-                                    #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init init of-                                      GHC.Types.LT ->-                                        (#-                                          init,-                                          failExp-                                        #)-                                      GHC.Types.EQ ->-                                        (#-                                          init,-                                          failExp GHC.Base.<> Data.Set.Internal.empty-                                        #)-                                      GHC.Types.GT ->-                                        (#-                                          init,-                                          Data.Set.Internal.empty-                                        #)-                               in finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure init farInp farExp
− test/Golden/Splice/G10.expected.txt 
@@ -1,243 +0,0 @@-\(input :: inp) ->-  let !(#-         init,-         readMore,-         readNext-         #) =-          let _ = "cursorOf"-           in let next-                    ( t@( Data.Text.Internal.Text-                            arr-                            off-                            unconsumed-                          )-                      ) =-                      let !( Data.Text.Unsafe.Iter-                               c-                               d-                             ) = Data.Text.Unsafe.iter t 0-                       in (#-                            c,-                            Data.Text.Internal.Text arr (off GHC.Num.+ d) (unconsumed GHC.Num.- d)-                          #)-                  more-                    ( Data.Text.Internal.Text-                        _-                        _-                        unconsumed-                      ) = unconsumed GHC.Classes.> 0-               in (# input, more, next #)-      finalRet = \_farInp _farExp v _inp -> Data.Either.Right v-      finalRaise ::-        forall b.-        Symantic.Parser.Machine.Generate.Catcher-          inp-          b = \(!exn) _failInp (!farInp) (!farExp) ->-          Data.Either.Left-            Symantic.Parser.Machine.Generate.ParsingError-              { Symantic.Parser.Machine.Generate.parsingErrorOffset = Symantic.Parser.Machine.Input.offset farInp,-                Symantic.Parser.Machine.Generate.parsingErrorException = exn,-                Symantic.Parser.Machine.Generate.parsingErrorUnexpected =-                  if readMore farInp-                    then-                      GHC.Maybe.Just-                        ( let (#-                                c,-                                _-                                #) = readNext farInp-                           in c-                        )-                    else GHC.Maybe.Nothing,-                Symantic.Parser.Machine.Generate.parsingErrorExpecting = farExp-              }-   in let inputToken = Data.Proxy.Proxy :: Data.Proxy.Proxy (Symantic.Parser.Machine.Input.InputToken inp)-       in let-           in let join = \farInp farExp v (!inp) ->-                    let _ = "resume"-                     in finalRet-                          farInp-                          farExp-                          ( let _ = "resume.genCode"-                             in GHC.Show.show v-                          )-                          inp-               in let _ = "catch ExceptionFailure"-                   in let catchHandler (!_exn) (!failInp) (!farInp) (!farExp) =-                            let _ = "catch.ko ExceptionFailure"-                             in if ( \( Data.Text.Internal.Text-                                          _-                                          i-                                          _-                                        )-                                      ( Data.Text.Internal.Text-                                          _-                                          j-                                          _-                                        ) -> i GHC.Classes.== j-                                   )-                                  init-                                  failInp-                                  then-                                    let _ = "choicesBranch.then"-                                     in let readFail = finalRaise-                                         in if readMore failInp-                                              then-                                                let !(#-                                                       c,-                                                       cs-                                                       #) = readNext failInp-                                                 in if (GHC.Classes.==) 'b' c-                                                      then-                                                        let _ = "resume"-                                                         in join-                                                              farInp-                                                              farExp-                                                              ( let _ = "resume.genCode"-                                                                 in 'b'-                                                              )-                                                              cs-                                                      else-                                                        let _ = "checkToken.else"-                                                         in let failExp =-                                                                  Data.Set.Internal.Bin-                                                                    1-                                                                    ( Symantic.Parser.Grammar.Combinators.SomeFailure-                                                                        ( case inputToken of-                                                                            (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken 'b'-                                                                        )-                                                                    )-                                                                    Data.Set.Internal.Tip-                                                                    Data.Set.Internal.Tip-                                                             in let (#-                                                                      farInp,-                                                                      farExp-                                                                      #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp failInp of-                                                                        GHC.Types.LT ->-                                                                          (#-                                                                            failInp,-                                                                            failExp-                                                                          #)-                                                                        GHC.Types.EQ ->-                                                                          (#-                                                                            farInp,-                                                                            failExp GHC.Base.<> farExp-                                                                          #)-                                                                        GHC.Types.GT ->-                                                                          (#-                                                                            farInp,-                                                                            farExp-                                                                          #)-                                                                 in finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp farInp farExp-                                              else-                                                let _ = "checkHorizon.else"-                                                 in let failExp =-                                                          Data.Set.Internal.Bin-                                                            1-                                                            ( Symantic.Parser.Grammar.Combinators.SomeFailure-                                                                ( case inputToken of-                                                                    (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureHorizon @tok' 1-                                                                )-                                                            )-                                                            Data.Set.Internal.Tip-                                                            Data.Set.Internal.Tip-                                                     in let (#-                                                              farInp,-                                                              farExp-                                                              #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp failInp of-                                                                GHC.Types.LT ->-                                                                  (#-                                                                    failInp,-                                                                    failExp-                                                                  #)-                                                                GHC.Types.EQ ->-                                                                  (#-                                                                    farInp,-                                                                    failExp GHC.Base.<> farExp-                                                                  #)-                                                                GHC.Types.GT ->-                                                                  (#-                                                                    farInp,-                                                                    farExp-                                                                  #)-                                                         in finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp farInp farExp-                                  else-                                    let _ = "choicesBranch.else"-                                     in finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp farInp farExp-                       in let readFail = catchHandler-                           in if readMore init-                                then-                                  let !(# c, cs #) = readNext init-                                   in if (GHC.Classes.==) 'a' c-                                        then-                                          let _ = "resume"-                                           in join-                                                init-                                                Data.Set.Internal.empty-                                                ( let _ = "resume.genCode"-                                                   in 'a'-                                                )-                                                cs-                                        else-                                          let _ = "checkToken.else"-                                           in let failExp =-                                                    Data.Set.Internal.Bin-                                                      1-                                                      ( Symantic.Parser.Grammar.Combinators.SomeFailure-                                                          ( case inputToken of-                                                              (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken 'a'-                                                          )-                                                      )-                                                      Data.Set.Internal.Tip-                                                      Data.Set.Internal.Tip-                                               in let (#-                                                        farInp,-                                                        farExp-                                                        #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init init of-                                                          GHC.Types.LT ->-                                                            (#-                                                              init,-                                                              failExp-                                                            #)-                                                          GHC.Types.EQ ->-                                                            (#-                                                              init,-                                                              failExp GHC.Base.<> Data.Set.Internal.empty-                                                            #)-                                                          GHC.Types.GT ->-                                                            (#-                                                              init,-                                                              Data.Set.Internal.empty-                                                            #)-                                                   in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure init farInp farExp-                                else-                                  let _ = "checkHorizon.else"-                                   in let failExp =-                                            Data.Set.Internal.Bin-                                              1-                                              ( Symantic.Parser.Grammar.Combinators.SomeFailure-                                                  ( case inputToken of-                                                      (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureHorizon @tok' 1-                                                  )-                                              )-                                              Data.Set.Internal.Tip-                                              Data.Set.Internal.Tip-                                       in let (#-                                                farInp,-                                                farExp-                                                #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init init of-                                                  GHC.Types.LT ->-                                                    (#-                                                      init,-                                                      failExp-                                                    #)-                                                  GHC.Types.EQ ->-                                                    (#-                                                      init,-                                                      failExp GHC.Base.<> Data.Set.Internal.empty-                                                    #)-                                                  GHC.Types.GT ->-                                                    (#-                                                      init,-                                                      Data.Set.Internal.empty-                                                    #)-                                           in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure init farInp farExp
− test/Golden/Splice/G11.expected.txt 
@@ -1,257 +0,0 @@-\(input :: inp) ->-  let !(#-         init,-         readMore,-         readNext-         #) =-          let _ = "cursorOf"-           in let next-                    ( t@( Data.Text.Internal.Text-                            arr-                            off-                            unconsumed-                          )-                      ) =-                      let !( Data.Text.Unsafe.Iter-                               c-                               d-                             ) = Data.Text.Unsafe.iter t 0-                       in (#-                            c,-                            Data.Text.Internal.Text arr (off GHC.Num.+ d) (unconsumed GHC.Num.- d)-                          #)-                  more-                    ( Data.Text.Internal.Text-                        _-                        _-                        unconsumed-                      ) = unconsumed GHC.Classes.> 0-               in (# input, more, next #)-      finalRet = \_farInp _farExp v _inp -> Data.Either.Right v-      finalRaise ::-        forall b.-        Symantic.Parser.Machine.Generate.Catcher-          inp-          b = \(!exn) _failInp (!farInp) (!farExp) ->-          Data.Either.Left-            Symantic.Parser.Machine.Generate.ParsingError-              { Symantic.Parser.Machine.Generate.parsingErrorOffset = Symantic.Parser.Machine.Input.offset farInp,-                Symantic.Parser.Machine.Generate.parsingErrorException = exn,-                Symantic.Parser.Machine.Generate.parsingErrorUnexpected =-                  if readMore farInp-                    then-                      GHC.Maybe.Just-                        ( let (#-                                c,-                                _-                                #) = readNext farInp-                           in c-                        )-                    else GHC.Maybe.Nothing,-                Symantic.Parser.Machine.Generate.parsingErrorExpecting = farExp-              }-   in let inputToken = Data.Proxy.Proxy :: Data.Proxy.Proxy (Symantic.Parser.Machine.Input.InputToken inp)-       in let name = \(!ok) (!inp) (!koByLabel) ->-                let _ = "catch ExceptionFailure"-                 in let catchHandler (!_exn) (!failInp) (!farInp) (!farExp) =-                          let _ = "catch.ko ExceptionFailure"-                           in if ( \( Data.Text.Internal.Text-                                        _-                                        i-                                        _-                                      )-                                    ( Data.Text.Internal.Text-                                        _-                                        j-                                        _-                                      ) -> i GHC.Classes.== j-                                 )-                                inp-                                failInp-                                then-                                  let _ = "choicesBranch.then"-                                   in let _ = "resume"-                                       in ok-                                            farInp-                                            farExp-                                            ( let _ = "resume.genCode"-                                               in \x -> x-                                            )-                                            failInp-                                else-                                  let _ = "choicesBranch.else"-                                   in Data.Map.Strict.Internal.findWithDefault finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure koByLabel Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp farInp farExp-                     in let readFail = catchHandler-                         in if readMore inp-                              then-                                let !(#-                                       c,-                                       cs-                                       #) = readNext inp-                                 in if (GHC.Classes.==) 'a' c-                                      then-                                        name-                                          ( let _ = "suspend"-                                             in \farInp farExp v (!inp) ->-                                                  let _ = "resume"-                                                   in ok-                                                        farInp-                                                        farExp-                                                        ( let _ = "resume.genCode"-                                                           in \x -> (GHC.Types.:) 'a' (v x)-                                                        )-                                                        inp-                                          )-                                          cs-                                          (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure readFail Data.Map.Internal.Tip Data.Map.Internal.Tip)-                                      else-                                        let _ = "checkToken.else"-                                         in let failExp =-                                                  Data.Set.Internal.Bin-                                                    1-                                                    ( Symantic.Parser.Grammar.Combinators.SomeFailure-                                                        ( case inputToken of-                                                            (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken 'a'-                                                        )-                                                    )-                                                    Data.Set.Internal.Tip-                                                    Data.Set.Internal.Tip-                                             in let (#-                                                      farInp,-                                                      farExp-                                                      #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init inp of-                                                        GHC.Types.LT ->-                                                          (#-                                                            inp,-                                                            failExp-                                                          #)-                                                        GHC.Types.EQ ->-                                                          (#-                                                            init,-                                                            failExp GHC.Base.<> Data.Set.Internal.empty-                                                          #)-                                                        GHC.Types.GT ->-                                                          (#-                                                            init,-                                                            Data.Set.Internal.empty-                                                          #)-                                                 in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp-                              else-                                let _ = "checkHorizon.else"-                                 in let failExp =-                                          Data.Set.Internal.Bin-                                            1-                                            ( Symantic.Parser.Grammar.Combinators.SomeFailure-                                                ( case inputToken of-                                                    (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureHorizon @tok' 1-                                                )-                                            )-                                            Data.Set.Internal.Tip-                                            Data.Set.Internal.Tip-                                     in let (#-                                              farInp,-                                              farExp-                                              #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init inp of-                                                GHC.Types.LT ->-                                                  (#-                                                    inp,-                                                    failExp-                                                  #)-                                                GHC.Types.EQ ->-                                                  (#-                                                    init,-                                                    failExp GHC.Base.<> Data.Set.Internal.empty-                                                  #)-                                                GHC.Types.GT ->-                                                  (#-                                                    init,-                                                    Data.Set.Internal.empty-                                                  #)-                                         in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp-           in name-                ( let _ = "suspend"-                   in \farInp farExp v (!inp) ->-                        let readFail = finalRaise-                         in if readMore inp-                              then-                                let !(#-                                       c,-                                       cs-                                       #) = readNext inp-                                 in if (GHC.Classes.==) 'b' c-                                      then-                                        let _ = "resume"-                                         in finalRet-                                              farInp-                                              farExp-                                              ( let _ = "resume.genCode"-                                                 in GHC.Show.show (v GHC.Types . [])-                                              )-                                              cs-                                      else-                                        let _ = "checkToken.else"-                                         in let failExp =-                                                  Data.Set.Internal.Bin-                                                    1-                                                    ( Symantic.Parser.Grammar.Combinators.SomeFailure-                                                        ( case inputToken of-                                                            (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken 'b'-                                                        )-                                                    )-                                                    Data.Set.Internal.Tip-                                                    Data.Set.Internal.Tip-                                             in let (#-                                                      farInp,-                                                      farExp-                                                      #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp inp of-                                                        GHC.Types.LT ->-                                                          (#-                                                            inp,-                                                            failExp-                                                          #)-                                                        GHC.Types.EQ ->-                                                          (#-                                                            farInp,-                                                            failExp GHC.Base.<> farExp-                                                          #)-                                                        GHC.Types.GT ->-                                                          (#-                                                            farInp,-                                                            farExp-                                                          #)-                                                 in finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp-                              else-                                let _ = "checkHorizon.else"-                                 in let failExp =-                                          Data.Set.Internal.Bin-                                            1-                                            ( Symantic.Parser.Grammar.Combinators.SomeFailure-                                                ( case inputToken of-                                                    (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureHorizon @tok' 1-                                                )-                                            )-                                            Data.Set.Internal.Tip-                                            Data.Set.Internal.Tip-                                     in let (#-                                              farInp,-                                              farExp-                                              #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp inp of-                                                GHC.Types.LT ->-                                                  (#-                                                    inp,-                                                    failExp-                                                  #)-                                                GHC.Types.EQ ->-                                                  (#-                                                    farInp,-                                                    failExp GHC.Base.<> farExp-                                                  #)-                                                GHC.Types.GT ->-                                                  (#-                                                    farInp,-                                                    farExp-                                                  #)-                                         in finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp-                )-                init-                Data.Map.Internal.Tip
− test/Golden/Splice/G12.expected.txt 
@@ -1,305 +0,0 @@-\(input :: inp) ->-  let !(#-         init,-         readMore,-         readNext-         #) =-          let _ = "cursorOf"-           in let next-                    ( t@( Data.Text.Internal.Text-                            arr-                            off-                            unconsumed-                          )-                      ) =-                      let !( Data.Text.Unsafe.Iter-                               c-                               d-                             ) = Data.Text.Unsafe.iter t 0-                       in (#-                            c,-                            Data.Text.Internal.Text arr (off GHC.Num.+ d) (unconsumed GHC.Num.- d)-                          #)-                  more-                    ( Data.Text.Internal.Text-                        _-                        _-                        unconsumed-                      ) = unconsumed GHC.Classes.> 0-               in (# input, more, next #)-      finalRet = \_farInp _farExp v _inp -> Data.Either.Right v-      finalRaise ::-        forall b.-        Symantic.Parser.Machine.Generate.Catcher-          inp-          b = \(!exn) _failInp (!farInp) (!farExp) ->-          Data.Either.Left-            Symantic.Parser.Machine.Generate.ParsingError-              { Symantic.Parser.Machine.Generate.parsingErrorOffset = Symantic.Parser.Machine.Input.offset farInp,-                Symantic.Parser.Machine.Generate.parsingErrorException = exn,-                Symantic.Parser.Machine.Generate.parsingErrorUnexpected =-                  if readMore farInp-                    then-                      GHC.Maybe.Just-                        ( let (#-                                c,-                                _-                                #) = readNext farInp-                           in c-                        )-                    else GHC.Maybe.Nothing,-                Symantic.Parser.Machine.Generate.parsingErrorExpecting = farExp-              }-   in let inputToken = Data.Proxy.Proxy :: Data.Proxy.Proxy (Symantic.Parser.Machine.Input.InputToken inp)-       in let name = \(!ok) (!inp) (!koByLabel) ->-                let _ = "catch ExceptionFailure"-                 in let catchHandler (!_exn) (!failInp) (!farInp) (!farExp) =-                          let _ = "catch.ko ExceptionFailure"-                           in if ( \( Data.Text.Internal.Text-                                        _-                                        i-                                        _-                                      )-                                    ( Data.Text.Internal.Text-                                        _-                                        j-                                        _-                                      ) -> i GHC.Classes.== j-                                 )-                                inp-                                failInp-                                then-                                  let _ = "choicesBranch.then"-                                   in let _ = "resume"-                                       in ok-                                            farInp-                                            farExp-                                            ( let _ = "resume.genCode"-                                               in \x -> x-                                            )-                                            failInp-                                else-                                  let _ = "choicesBranch.else"-                                   in Data.Map.Strict.Internal.findWithDefault finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure koByLabel Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp farInp farExp-                     in let readFail = catchHandler-                         in if readMore inp-                              then-                                let !(#-                                       c,-                                       cs-                                       #) = readNext inp-                                 in if (\t -> ('a' GHC.Classes.== t) GHC.Classes.|| (('b' GHC.Classes.== t) GHC.Classes.|| (('c' GHC.Classes.== t) GHC.Classes.|| (('d' GHC.Classes.== t) GHC.Classes.|| GHC.Types.False)))) c-                                      then-                                        name-                                          ( let _ = "suspend"-                                             in \farInp farExp v (!inp) ->-                                                  let _ = "resume"-                                                   in ok-                                                        farInp-                                                        farExp-                                                        ( let _ = "resume.genCode"-                                                           in \x -> (GHC.Types.:) c (v x)-                                                        )-                                                        inp-                                          )-                                          cs-                                          (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure readFail Data.Map.Internal.Tip Data.Map.Internal.Tip)-                                      else-                                        let _ = "checkToken.else"-                                         in let failExp =-                                                  Data.Set.Internal.Bin-                                                    4-                                                    ( Symantic.Parser.Grammar.Combinators.SomeFailure-                                                        ( case inputToken of-                                                            (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken 'b'-                                                        )-                                                    )-                                                    ( Data.Set.Internal.Bin-                                                        1-                                                        ( Symantic.Parser.Grammar.Combinators.SomeFailure-                                                            ( case inputToken of-                                                                (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken 'a'-                                                            )-                                                        )-                                                        Data.Set.Internal.Tip-                                                        Data.Set.Internal.Tip-                                                    )-                                                    ( Data.Set.Internal.Bin-                                                        2-                                                        ( Symantic.Parser.Grammar.Combinators.SomeFailure-                                                            ( case inputToken of-                                                                (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken 'c'-                                                            )-                                                        )-                                                        Data.Set.Internal.Tip-                                                        ( Data.Set.Internal.Bin-                                                            1-                                                            ( Symantic.Parser.Grammar.Combinators.SomeFailure-                                                                ( case inputToken of-                                                                    (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken 'd'-                                                                )-                                                            )-                                                            Data.Set.Internal.Tip-                                                            Data.Set.Internal.Tip-                                                        )-                                                    )-                                             in let (#-                                                      farInp,-                                                      farExp-                                                      #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init inp of-                                                        GHC.Types.LT ->-                                                          (#-                                                            inp,-                                                            failExp-                                                          #)-                                                        GHC.Types.EQ ->-                                                          (#-                                                            init,-                                                            failExp GHC.Base.<> Data.Set.Internal.empty-                                                          #)-                                                        GHC.Types.GT ->-                                                          (#-                                                            init,-                                                            Data.Set.Internal.empty-                                                          #)-                                                 in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp-                              else-                                let _ = "checkHorizon.else"-                                 in let failExp =-                                          Data.Set.Internal.Bin-                                            1-                                            ( Symantic.Parser.Grammar.Combinators.SomeFailure-                                                ( case inputToken of-                                                    (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureHorizon @tok' 1-                                                )-                                            )-                                            Data.Set.Internal.Tip-                                            Data.Set.Internal.Tip-                                     in let (#-                                              farInp,-                                              farExp-                                              #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init inp of-                                                GHC.Types.LT ->-                                                  (#-                                                    inp,-                                                    failExp-                                                  #)-                                                GHC.Types.EQ ->-                                                  (#-                                                    init,-                                                    failExp GHC.Base.<> Data.Set.Internal.empty-                                                  #)-                                                GHC.Types.GT ->-                                                  (#-                                                    init,-                                                    Data.Set.Internal.empty-                                                  #)-                                         in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp-           in name-                ( let _ = "suspend"-                   in \farInp farExp v (!inp) ->-                        let join = \farInp farExp v (!inp) ->-                              let _ = "resume"-                               in finalRet-                                    farInp-                                    farExp-                                    ( let _ = "resume.genCode"-                                       in GHC.Show.show (v GHC.Types . [])-                                    )-                                    inp-                         in let _ = "catch ExceptionFailure"-                             in let catchHandler (!_exn) (!failInp) (!farInp) (!farExp) =-                                      let _ = "catch.ko ExceptionFailure"-                                       in if ( \( Data.Text.Internal.Text-                                                    _-                                                    i-                                                    _-                                                  )-                                                ( Data.Text.Internal.Text-                                                    _-                                                    j-                                                    _-                                                  ) -> i GHC.Classes.== j-                                             )-                                            inp-                                            failInp-                                            then-                                              let _ = "choicesBranch.then"-                                               in let failExp = Data.Set.Internal.Bin 1 (Symantic.Parser.Grammar.Combinators.SomeFailure Symantic.Parser.Grammar.Combinators.FailureEnd) Data.Set.Internal.Tip Data.Set.Internal.Tip-                                                   in let (#-                                                            farInp,-                                                            farExp-                                                            #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp failInp of-                                                              GHC.Types.LT ->-                                                                (#-                                                                  failInp,-                                                                  failExp-                                                                #)-                                                              GHC.Types.EQ ->-                                                                (#-                                                                  farInp,-                                                                  failExp GHC.Base.<> farExp-                                                                #)-                                                              GHC.Types.GT ->-                                                                (#-                                                                  farInp,-                                                                  farExp-                                                                #)-                                                       in finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp farInp farExp-                                            else-                                              let _ = "choicesBranch.else"-                                               in finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp farInp farExp-                                 in let _ = "catch ExceptionFailure"-                                     in let catchHandler (!_exn) (!failInp) (!farInp) (!farExp) =-                                              let _ = "catch.ko ExceptionFailure"-                                               in let _ = "resume"-                                                   in join-                                                        farInp-                                                        farExp-                                                        ( let _ = "resume.genCode"-                                                           in GHC.Tuple . ()-                                                        )-                                                        inp-                                         in let readFail = catchHandler-                                             in if readMore inp-                                                  then-                                                    let !(#-                                                           c,-                                                           cs-                                                           #) = readNext inp-                                                     in catchHandler Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp-                                                  else-                                                    let _ = "checkHorizon.else"-                                                     in let failExp =-                                                              Data.Set.Internal.Bin-                                                                1-                                                                ( Symantic.Parser.Grammar.Combinators.SomeFailure-                                                                    ( case inputToken of-                                                                        (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureHorizon @tok' 1-                                                                    )-                                                                )-                                                                Data.Set.Internal.Tip-                                                                Data.Set.Internal.Tip-                                                         in let (#-                                                                  farInp,-                                                                  farExp-                                                                  #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp inp of-                                                                    GHC.Types.LT ->-                                                                      (#-                                                                        inp,-                                                                        failExp-                                                                      #)-                                                                    GHC.Types.EQ ->-                                                                      (#-                                                                        farInp,-                                                                        failExp GHC.Base.<> farExp-                                                                      #)-                                                                    GHC.Types.GT ->-                                                                      (#-                                                                        farInp,-                                                                        farExp-                                                                      #)-                                                             in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp-                )-                init-                Data.Map.Internal.Tip
− test/Golden/Splice/G13.expected.txt 
@@ -1,722 +0,0 @@-\(input :: inp) ->-  let !(#-         init,-         readMore,-         readNext-         #) =-          let _ = "cursorOf"-           in let next-                    ( t@( Data.Text.Internal.Text-                            arr-                            off-                            unconsumed-                          )-                      ) =-                      let !( Data.Text.Unsafe.Iter-                               c-                               d-                             ) = Data.Text.Unsafe.iter t 0-                       in (#-                            c,-                            Data.Text.Internal.Text arr (off GHC.Num.+ d) (unconsumed GHC.Num.- d)-                          #)-                  more-                    ( Data.Text.Internal.Text-                        _-                        _-                        unconsumed-                      ) = unconsumed GHC.Classes.> 0-               in (# input, more, next #)-      finalRet = \_farInp _farExp v _inp -> Data.Either.Right v-      finalRaise ::-        forall b.-        Symantic.Parser.Machine.Generate.Catcher-          inp-          b = \(!exn) _failInp (!farInp) (!farExp) ->-          Data.Either.Left-            Symantic.Parser.Machine.Generate.ParsingError-              { Symantic.Parser.Machine.Generate.parsingErrorOffset = Symantic.Parser.Machine.Input.offset farInp,-                Symantic.Parser.Machine.Generate.parsingErrorException = exn,-                Symantic.Parser.Machine.Generate.parsingErrorUnexpected =-                  if readMore farInp-                    then-                      GHC.Maybe.Just-                        ( let (#-                                c,-                                _-                                #) = readNext farInp-                           in c-                        )-                    else GHC.Maybe.Nothing,-                Symantic.Parser.Machine.Generate.parsingErrorExpecting = farExp-              }-   in let inputToken = Data.Proxy.Proxy :: Data.Proxy.Proxy (Symantic.Parser.Machine.Input.InputToken inp)-       in let name = \(!ok) (!inp) (!koByLabel) ->-                name-                  ( let _ = "suspend"-                     in \farInp farExp v (!inp) ->-                          let _ = "resume"-                           in ok-                                farInp-                                farExp-                                ( let _ = "resume.genCode"-                                   in GHC.Tuple . ()-                                )-                                inp-                  )-                  inp-                  (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure (Data.Map.Strict.Internal.findWithDefault finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure koByLabel) Data.Map.Internal.Tip Data.Map.Internal.Tip)-              name = \(!ok) (!inp) (!koByLabel) ->-                name-                  ( let _ = "suspend"-                     in \farInp farExp v (!inp) ->-                          let _ = "resume"-                           in ok-                                farInp-                                farExp-                                ( let _ = "resume.genCode"-                                   in v GHC.Types . []-                                )-                                inp-                  )-                  inp-                  (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure (Data.Map.Strict.Internal.findWithDefault finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure koByLabel) Data.Map.Internal.Tip Data.Map.Internal.Tip)-              name = \(!ok) (!inp) (!koByLabel) ->-                let _ = "catch ExceptionFailure"-                 in let catchHandler (!_exn) (!failInp) (!farInp) (!farExp) =-                          let _ = "catch.ko ExceptionFailure"-                           in if ( \( Data.Text.Internal.Text-                                        _-                                        i-                                        _-                                      )-                                    ( Data.Text.Internal.Text-                                        _-                                        j-                                        _-                                      ) -> i GHC.Classes.== j-                                 )-                                inp-                                failInp-                                then-                                  let _ = "choicesBranch.then"-                                   in let _ = "resume"-                                       in ok-                                            farInp-                                            farExp-                                            ( let _ = "resume.genCode"-                                               in \x -> x-                                            )-                                            failInp-                                else-                                  let _ = "choicesBranch.else"-                                   in Data.Map.Strict.Internal.findWithDefault finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure koByLabel Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp farInp farExp-                     in let join = \farInp farExp v (!inp) ->-                              name-                                ( let _ = "suspend"-                                   in \farInp farExp v (!inp) ->-                                        name-                                          ( let _ = "suspend"-                                             in \farInp farExp v (!inp) ->-                                                  let _ = "resume"-                                                   in ok-                                                        farInp-                                                        farExp-                                                        ( let _ = "resume.genCode"-                                                           in \x -> (GHC.Types.:) v (v x)-                                                        )-                                                        inp-                                          )-                                          inp-                                          (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure catchHandler Data.Map.Internal.Tip Data.Map.Internal.Tip)-                                )-                                inp-                                (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure catchHandler Data.Map.Internal.Tip Data.Map.Internal.Tip)-                         in let readFail = catchHandler-                             in if readMore inp-                                  then-                                    let !(#-                                           c,-                                           cs-                                           #) = readNext inp-                                     in if (GHC.Classes.==) '<' c-                                          then-                                            let _ = "choicesBranch.then"-                                             in let readFail = readFail-                                                 in if readMore inp-                                                      then-                                                        let !(#-                                                               c,-                                                               cs-                                                               #) = readNext inp-                                                         in let _ = "resume"-                                                             in join-                                                                  init-                                                                  Data.Set.Internal.empty-                                                                  ( let _ = "resume.genCode"-                                                                     in Parsers.Brainfuck.Types.Backward-                                                                  )-                                                                  cs-                                                      else-                                                        let _ = "checkHorizon.else"-                                                         in let failExp =-                                                                  Data.Set.Internal.Bin-                                                                    1-                                                                    ( Symantic.Parser.Grammar.Combinators.SomeFailure-                                                                        ( case inputToken of-                                                                            (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureHorizon @tok' 1-                                                                        )-                                                                    )-                                                                    Data.Set.Internal.Tip-                                                                    Data.Set.Internal.Tip-                                                             in let (#-                                                                      farInp,-                                                                      farExp-                                                                      #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init inp of-                                                                        GHC.Types.LT ->-                                                                          (#-                                                                            inp,-                                                                            failExp-                                                                          #)-                                                                        GHC.Types.EQ ->-                                                                          (#-                                                                            init,-                                                                            failExp GHC.Base.<> Data.Set.Internal.empty-                                                                          #)-                                                                        GHC.Types.GT ->-                                                                          (#-                                                                            init,-                                                                            Data.Set.Internal.empty-                                                                          #)-                                                                 in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp-                                          else-                                            let _ = "choicesBranch.else"-                                             in if (GHC.Classes.==) '>' c-                                                  then-                                                    let _ = "choicesBranch.then"-                                                     in let readFail = readFail-                                                         in if readMore inp-                                                              then-                                                                let !(#-                                                                       c,-                                                                       cs-                                                                       #) = readNext inp-                                                                 in let _ = "resume"-                                                                     in join-                                                                          init-                                                                          Data.Set.Internal.empty-                                                                          ( let _ = "resume.genCode"-                                                                             in Parsers.Brainfuck.Types.Forward-                                                                          )-                                                                          cs-                                                              else-                                                                let _ = "checkHorizon.else"-                                                                 in let failExp =-                                                                          Data.Set.Internal.Bin-                                                                            1-                                                                            ( Symantic.Parser.Grammar.Combinators.SomeFailure-                                                                                ( case inputToken of-                                                                                    (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureHorizon @tok' 1-                                                                                )-                                                                            )-                                                                            Data.Set.Internal.Tip-                                                                            Data.Set.Internal.Tip-                                                                     in let (#-                                                                              farInp,-                                                                              farExp-                                                                              #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init inp of-                                                                                GHC.Types.LT ->-                                                                                  (#-                                                                                    inp,-                                                                                    failExp-                                                                                  #)-                                                                                GHC.Types.EQ ->-                                                                                  (#-                                                                                    init,-                                                                                    failExp GHC.Base.<> Data.Set.Internal.empty-                                                                                  #)-                                                                                GHC.Types.GT ->-                                                                                  (#-                                                                                    init,-                                                                                    Data.Set.Internal.empty-                                                                                  #)-                                                                         in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp-                                                  else-                                                    let _ = "choicesBranch.else"-                                                     in if (GHC.Classes.==) '+' c-                                                          then-                                                            let _ = "choicesBranch.then"-                                                             in let readFail = readFail-                                                                 in if readMore inp-                                                                      then-                                                                        let !(#-                                                                               c,-                                                                               cs-                                                                               #) = readNext inp-                                                                         in let _ = "resume"-                                                                             in join-                                                                                  init-                                                                                  Data.Set.Internal.empty-                                                                                  ( let _ = "resume.genCode"-                                                                                     in Parsers.Brainfuck.Types.Increment-                                                                                  )-                                                                                  cs-                                                                      else-                                                                        let _ = "checkHorizon.else"-                                                                         in let failExp =-                                                                                  Data.Set.Internal.Bin-                                                                                    1-                                                                                    ( Symantic.Parser.Grammar.Combinators.SomeFailure-                                                                                        ( case inputToken of-                                                                                            (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureHorizon @tok' 1-                                                                                        )-                                                                                    )-                                                                                    Data.Set.Internal.Tip-                                                                                    Data.Set.Internal.Tip-                                                                             in let (#-                                                                                      farInp,-                                                                                      farExp-                                                                                      #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init inp of-                                                                                        GHC.Types.LT ->-                                                                                          (#-                                                                                            inp,-                                                                                            failExp-                                                                                          #)-                                                                                        GHC.Types.EQ ->-                                                                                          (#-                                                                                            init,-                                                                                            failExp GHC.Base.<> Data.Set.Internal.empty-                                                                                          #)-                                                                                        GHC.Types.GT ->-                                                                                          (#-                                                                                            init,-                                                                                            Data.Set.Internal.empty-                                                                                          #)-                                                                                 in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp-                                                          else-                                                            let _ = "choicesBranch.else"-                                                             in if (GHC.Classes.==) '-' c-                                                                  then-                                                                    let _ = "choicesBranch.then"-                                                                     in let readFail = readFail-                                                                         in if readMore inp-                                                                              then-                                                                                let !(#-                                                                                       c,-                                                                                       cs-                                                                                       #) = readNext inp-                                                                                 in let _ = "resume"-                                                                                     in join-                                                                                          init-                                                                                          Data.Set.Internal.empty-                                                                                          ( let _ = "resume.genCode"-                                                                                             in Parsers.Brainfuck.Types.Decrement-                                                                                          )-                                                                                          cs-                                                                              else-                                                                                let _ = "checkHorizon.else"-                                                                                 in let failExp =-                                                                                          Data.Set.Internal.Bin-                                                                                            1-                                                                                            ( Symantic.Parser.Grammar.Combinators.SomeFailure-                                                                                                ( case inputToken of-                                                                                                    (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureHorizon @tok' 1-                                                                                                )-                                                                                            )-                                                                                            Data.Set.Internal.Tip-                                                                                            Data.Set.Internal.Tip-                                                                                     in let (#-                                                                                              farInp,-                                                                                              farExp-                                                                                              #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init inp of-                                                                                                GHC.Types.LT ->-                                                                                                  (#-                                                                                                    inp,-                                                                                                    failExp-                                                                                                  #)-                                                                                                GHC.Types.EQ ->-                                                                                                  (#-                                                                                                    init,-                                                                                                    failExp GHC.Base.<> Data.Set.Internal.empty-                                                                                                  #)-                                                                                                GHC.Types.GT ->-                                                                                                  (#-                                                                                                    init,-                                                                                                    Data.Set.Internal.empty-                                                                                                  #)-                                                                                         in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp-                                                                  else-                                                                    let _ = "choicesBranch.else"-                                                                     in if (GHC.Classes.==) ',' c-                                                                          then-                                                                            let _ = "choicesBranch.then"-                                                                             in let readFail = readFail-                                                                                 in if readMore inp-                                                                                      then-                                                                                        let !(#-                                                                                               c,-                                                                                               cs-                                                                                               #) = readNext inp-                                                                                         in let _ = "resume"-                                                                                             in join-                                                                                                  init-                                                                                                  Data.Set.Internal.empty-                                                                                                  ( let _ = "resume.genCode"-                                                                                                     in Parsers.Brainfuck.Types.Input-                                                                                                  )-                                                                                                  cs-                                                                                      else-                                                                                        let _ = "checkHorizon.else"-                                                                                         in let failExp =-                                                                                                  Data.Set.Internal.Bin-                                                                                                    1-                                                                                                    ( Symantic.Parser.Grammar.Combinators.SomeFailure-                                                                                                        ( case inputToken of-                                                                                                            (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureHorizon @tok' 1-                                                                                                        )-                                                                                                    )-                                                                                                    Data.Set.Internal.Tip-                                                                                                    Data.Set.Internal.Tip-                                                                                             in let (#-                                                                                                      farInp,-                                                                                                      farExp-                                                                                                      #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init inp of-                                                                                                        GHC.Types.LT ->-                                                                                                          (#-                                                                                                            inp,-                                                                                                            failExp-                                                                                                          #)-                                                                                                        GHC.Types.EQ ->-                                                                                                          (#-                                                                                                            init,-                                                                                                            failExp GHC.Base.<> Data.Set.Internal.empty-                                                                                                          #)-                                                                                                        GHC.Types.GT ->-                                                                                                          (#-                                                                                                            init,-                                                                                                            Data.Set.Internal.empty-                                                                                                          #)-                                                                                                 in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp-                                                                          else-                                                                            let _ = "choicesBranch.else"-                                                                             in if (GHC.Classes.==) '.' c-                                                                                  then-                                                                                    let _ = "choicesBranch.then"-                                                                                     in let readFail = readFail-                                                                                         in if readMore inp-                                                                                              then-                                                                                                let !(#-                                                                                                       c,-                                                                                                       cs-                                                                                                       #) = readNext inp-                                                                                                 in let _ = "resume"-                                                                                                     in join-                                                                                                          init-                                                                                                          Data.Set.Internal.empty-                                                                                                          ( let _ = "resume.genCode"-                                                                                                             in Parsers.Brainfuck.Types.Output-                                                                                                          )-                                                                                                          cs-                                                                                              else-                                                                                                let _ = "checkHorizon.else"-                                                                                                 in let failExp =-                                                                                                          Data.Set.Internal.Bin-                                                                                                            1-                                                                                                            ( Symantic.Parser.Grammar.Combinators.SomeFailure-                                                                                                                ( case inputToken of-                                                                                                                    (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureHorizon @tok' 1-                                                                                                                )-                                                                                                            )-                                                                                                            Data.Set.Internal.Tip-                                                                                                            Data.Set.Internal.Tip-                                                                                                     in let (#-                                                                                                              farInp,-                                                                                                              farExp-                                                                                                              #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init inp of-                                                                                                                GHC.Types.LT ->-                                                                                                                  (#-                                                                                                                    inp,-                                                                                                                    failExp-                                                                                                                  #)-                                                                                                                GHC.Types.EQ ->-                                                                                                                  (#-                                                                                                                    init,-                                                                                                                    failExp GHC.Base.<> Data.Set.Internal.empty-                                                                                                                  #)-                                                                                                                GHC.Types.GT ->-                                                                                                                  (#-                                                                                                                    init,-                                                                                                                    Data.Set.Internal.empty-                                                                                                                  #)-                                                                                                         in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp-                                                                                  else-                                                                                    let _ = "choicesBranch.else"-                                                                                     in if (GHC.Classes.==) '[' c-                                                                                          then-                                                                                            let _ = "choicesBranch.then"-                                                                                             in let readFail = readFail-                                                                                                 in if readMore (Symantic.Parser.Machine.Input.shiftRightText 1 inp)-                                                                                                      then-                                                                                                        let !(#-                                                                                                               c,-                                                                                                               cs-                                                                                                               #) = readNext inp-                                                                                                         in name-                                                                                                              ( let _ = "suspend"-                                                                                                                 in \farInp farExp v (!inp) ->-                                                                                                                      name-                                                                                                                        ( let _ = "suspend"-                                                                                                                           in \farInp farExp v (!inp) ->-                                                                                                                                let readFail = readFail-                                                                                                                                 in if readMore inp-                                                                                                                                      then-                                                                                                                                        let !(#-                                                                                                                                               c,-                                                                                                                                               cs-                                                                                                                                               #) = readNext inp-                                                                                                                                         in if (GHC.Classes.==) ']' c-                                                                                                                                              then-                                                                                                                                                let _ = "resume"-                                                                                                                                                 in join-                                                                                                                                                      farInp-                                                                                                                                                      farExp-                                                                                                                                                      ( let _ = "resume.genCode"-                                                                                                                                                         in Parsers.Brainfuck.Types.Loop v-                                                                                                                                                      )-                                                                                                                                                      cs-                                                                                                                                              else-                                                                                                                                                let _ = "checkToken.else"-                                                                                                                                                 in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp-                                                                                                                                      else-                                                                                                                                        let _ = "checkHorizon.else"-                                                                                                                                         in let failExp =-                                                                                                                                                  Data.Set.Internal.Bin-                                                                                                                                                    1-                                                                                                                                                    ( Symantic.Parser.Grammar.Combinators.SomeFailure-                                                                                                                                                        ( case inputToken of-                                                                                                                                                            (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureHorizon @tok' 1-                                                                                                                                                        )-                                                                                                                                                    )-                                                                                                                                                    Data.Set.Internal.Tip-                                                                                                                                                    Data.Set.Internal.Tip-                                                                                                                                             in let (#-                                                                                                                                                      farInp,-                                                                                                                                                      farExp-                                                                                                                                                      #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp inp of-                                                                                                                                                        GHC.Types.LT ->-                                                                                                                                                          (#-                                                                                                                                                            inp,-                                                                                                                                                            failExp-                                                                                                                                                          #)-                                                                                                                                                        GHC.Types.EQ ->-                                                                                                                                                          (#-                                                                                                                                                            farInp,-                                                                                                                                                            failExp GHC.Base.<> farExp-                                                                                                                                                          #)-                                                                                                                                                        GHC.Types.GT ->-                                                                                                                                                          (#-                                                                                                                                                            farInp,-                                                                                                                                                            farExp-                                                                                                                                                          #)-                                                                                                                                                 in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp-                                                                                                                        )-                                                                                                                        inp-                                                                                                                        (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure readFail Data.Map.Internal.Tip Data.Map.Internal.Tip)-                                                                                                              )-                                                                                                              cs-                                                                                                              (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure readFail Data.Map.Internal.Tip Data.Map.Internal.Tip)-                                                                                                      else-                                                                                                        let _ = "checkHorizon.else"-                                                                                                         in let failExp =-                                                                                                                  Data.Set.Internal.Bin-                                                                                                                    1-                                                                                                                    ( Symantic.Parser.Grammar.Combinators.SomeFailure-                                                                                                                        ( case inputToken of-                                                                                                                            (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureHorizon @tok' 2-                                                                                                                        )-                                                                                                                    )-                                                                                                                    Data.Set.Internal.Tip-                                                                                                                    Data.Set.Internal.Tip-                                                                                                             in let (#-                                                                                                                      farInp,-                                                                                                                      farExp-                                                                                                                      #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init inp of-                                                                                                                        GHC.Types.LT ->-                                                                                                                          (#-                                                                                                                            inp,-                                                                                                                            failExp-                                                                                                                          #)-                                                                                                                        GHC.Types.EQ ->-                                                                                                                          (#-                                                                                                                            init,-                                                                                                                            failExp GHC.Base.<> Data.Set.Internal.empty-                                                                                                                          #)-                                                                                                                        GHC.Types.GT ->-                                                                                                                          (#-                                                                                                                            init,-                                                                                                                            Data.Set.Internal.empty-                                                                                                                          #)-                                                                                                                 in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp-                                                                                          else-                                                                                            let _ = "choicesBranch.else"-                                                                                             in let failExp = Data.Set.Internal.Bin 1 (Symantic.Parser.Grammar.Combinators.SomeFailure Symantic.Parser.Grammar.Combinators.FailureEmpty) Data.Set.Internal.Tip Data.Set.Internal.Tip-                                                                                                 in let (#-                                                                                                          farInp,-                                                                                                          farExp-                                                                                                          #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init inp of-                                                                                                            GHC.Types.LT ->-                                                                                                              (#-                                                                                                                inp,-                                                                                                                failExp-                                                                                                              #)-                                                                                                            GHC.Types.EQ ->-                                                                                                              (#-                                                                                                                init,-                                                                                                                failExp GHC.Base.<> Data.Set.Internal.empty-                                                                                                              #)-                                                                                                            GHC.Types.GT ->-                                                                                                              (#-                                                                                                                init,-                                                                                                                Data.Set.Internal.empty-                                                                                                              #)-                                                                                                     in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp-                                  else-                                    let _ = "checkHorizon.else"-                                     in let failExp =-                                              Data.Set.Internal.Bin-                                                1-                                                ( Symantic.Parser.Grammar.Combinators.SomeFailure-                                                    ( case inputToken of-                                                        (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureHorizon @tok' 1-                                                    )-                                                )-                                                Data.Set.Internal.Tip-                                                Data.Set.Internal.Tip-                                         in let (#-                                                  farInp,-                                                  farExp-                                                  #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init inp of-                                                    GHC.Types.LT ->-                                                      (#-                                                        inp,-                                                        failExp-                                                      #)-                                                    GHC.Types.EQ ->-                                                      (#-                                                        init,-                                                        failExp GHC.Base.<> Data.Set.Internal.empty-                                                      #)-                                                    GHC.Types.GT ->-                                                      (#-                                                        init,-                                                        Data.Set.Internal.empty-                                                      #)-                                             in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp-              name = \(!ok) (!inp) (!koByLabel) ->-                let _ = "catch ExceptionFailure"-                 in let catchHandler (!_exn) (!failInp) (!farInp) (!farExp) =-                          let _ = "catch.ko ExceptionFailure"-                           in if ( \( Data.Text.Internal.Text-                                        _-                                        i-                                        _-                                      )-                                    ( Data.Text.Internal.Text-                                        _-                                        j-                                        _-                                      ) -> i GHC.Classes.== j-                                 )-                                inp-                                failInp-                                then-                                  let _ = "choicesBranch.then"-                                   in let _ = "resume"-                                       in ok-                                            farInp-                                            farExp-                                            ( let _ = "resume.genCode"-                                               in \x -> x-                                            )-                                            failInp-                                else-                                  let _ = "choicesBranch.else"-                                   in Data.Map.Strict.Internal.findWithDefault finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure koByLabel Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp farInp farExp-                     in let readFail = catchHandler-                         in if readMore inp-                              then-                                let !(#-                                       c,-                                       cs-                                       #) = readNext inp-                                 in if (\c -> GHC.Classes.not (('<' GHC.Classes.== c) GHC.Classes.|| (('>' GHC.Classes.== c) GHC.Classes.|| (('+' GHC.Classes.== c) GHC.Classes.|| (('-' GHC.Classes.== c) GHC.Classes.|| ((',' GHC.Classes.== c) GHC.Classes.|| (('.' GHC.Classes.== c) GHC.Classes.|| (('[' GHC.Classes.== c) GHC.Classes.|| ((']' GHC.Classes.== c) GHC.Classes.|| GHC.Types.False))))))))) c-                                      then-                                        name-                                          ( let _ = "suspend"-                                             in \farInp farExp v (!inp) ->-                                                  let _ = "resume"-                                                   in ok-                                                        farInp-                                                        farExp-                                                        ( let _ = "resume.genCode"-                                                           in \x -> v x-                                                        )-                                                        inp-                                          )-                                          cs-                                          (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure readFail Data.Map.Internal.Tip Data.Map.Internal.Tip)-                                      else-                                        let _ = "checkToken.else"-                                         in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure inp init Data.Set.Internal.empty-                              else-                                let _ = "checkHorizon.else"-                                 in let failExp =-                                          Data.Set.Internal.Bin-                                            1-                                            ( Symantic.Parser.Grammar.Combinators.SomeFailure-                                                ( case inputToken of-                                                    (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureHorizon @tok' 1-                                                )-                                            )-                                            Data.Set.Internal.Tip-                                            Data.Set.Internal.Tip-                                     in let (#-                                              farInp,-                                              farExp-                                              #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init inp of-                                                GHC.Types.LT ->-                                                  (#-                                                    inp,-                                                    failExp-                                                  #)-                                                GHC.Types.EQ ->-                                                  (#-                                                    init,-                                                    failExp GHC.Base.<> Data.Set.Internal.empty-                                                  #)-                                                GHC.Types.GT ->-                                                  (#-                                                    init,-                                                    Data.Set.Internal.empty-                                                  #)-                                         in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp-           in name-                ( let _ = "suspend"-                   in \farInp farExp v (!inp) ->-                        name-                          ( let _ = "suspend"-                             in \farInp farExp v (!inp) ->-                                  let _ = "resume"-                                   in finalRet-                                        farInp-                                        farExp-                                        ( let _ = "resume.genCode"-                                           in GHC.Show.show v-                                        )-                                        inp-                          )-                          inp-                          Data.Map.Internal.Tip-                )-                init-                Data.Map.Internal.Tip
− test/Golden/Splice/G14.expected.txt 
@@ -1,4218 +0,0 @@-\(input :: inp) ->-  let !(#-         init,-         readMore,-         readNext-         #) =-          let _ = "cursorOf"-           in let next-                    ( t@( Data.Text.Internal.Text-                            arr-                            off-                            unconsumed-                          )-                      ) =-                      let !( Data.Text.Unsafe.Iter-                               c-                               d-                             ) = Data.Text.Unsafe.iter t 0-                       in (#-                            c,-                            Data.Text.Internal.Text arr (off GHC.Num.+ d) (unconsumed GHC.Num.- d)-                          #)-                  more-                    ( Data.Text.Internal.Text-                        _-                        _-                        unconsumed-                      ) = unconsumed GHC.Classes.> 0-               in (# input, more, next #)-      finalRet = \_farInp _farExp v _inp -> Data.Either.Right v-      finalRaise ::-        forall b.-        Symantic.Parser.Machine.Generate.Catcher-          inp-          b = \(!exn) _failInp (!farInp) (!farExp) ->-          Data.Either.Left-            Symantic.Parser.Machine.Generate.ParsingError-              { Symantic.Parser.Machine.Generate.parsingErrorOffset = Symantic.Parser.Machine.Input.offset farInp,-                Symantic.Parser.Machine.Generate.parsingErrorException = exn,-                Symantic.Parser.Machine.Generate.parsingErrorUnexpected =-                  if readMore farInp-                    then-                      GHC.Maybe.Just-                        ( let (#-                                c,-                                _-                                #) = readNext farInp-                           in c-                        )-                    else GHC.Maybe.Nothing,-                Symantic.Parser.Machine.Generate.parsingErrorExpecting = farExp-              }-   in let inputToken = Data.Proxy.Proxy :: Data.Proxy.Proxy (Symantic.Parser.Machine.Input.InputToken inp)-       in let name = \(!ok) (!inp) (!koByLabel) ->-                name-                  ( let _ = "suspend"-                     in \farInp farExp v (!inp) ->-                          name-                            ( let _ = "suspend"-                               in \farInp farExp v (!inp) ->-                                    name-                                      ( let _ = "suspend"-                                         in \farInp farExp v (!inp) ->-                                              name-                                                ( let _ = "suspend"-                                                   in \farInp farExp v (!inp) ->-                                                        let _ = "resume"-                                                         in ok-                                                              farInp-                                                              farExp-                                                              ( let _ = "resume.genCode"-                                                                 in v-                                                              )-                                                              inp-                                                )-                                                inp-                                                Data.Map.Internal.Tip-                                      )-                                      inp-                                      (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure (Data.Map.Strict.Internal.findWithDefault finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure koByLabel) Data.Map.Internal.Tip Data.Map.Internal.Tip)-                            )-                            inp-                            Data.Map.Internal.Tip-                  )-                  inp-                  (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure (Data.Map.Strict.Internal.findWithDefault finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure koByLabel) Data.Map.Internal.Tip Data.Map.Internal.Tip)-              name = \(!ok) (!inp) (!koByLabel) ->-                name-                  ( let _ = "suspend"-                     in \farInp farExp v (!inp) ->-                          name-                            ( let _ = "suspend"-                               in \farInp farExp v (!inp) ->-                                    let _ = "resume"-                                     in ok-                                          farInp-                                          farExp-                                          ( let _ = "resume.genCode"-                                             in GHC.Tuple . ()-                                          )-                                          inp-                            )-                            inp-                            (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure (Data.Map.Strict.Internal.findWithDefault finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure koByLabel) Data.Map.Internal.Tip Data.Map.Internal.Tip)-                  )-                  inp-                  (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure (Data.Map.Strict.Internal.findWithDefault finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure koByLabel) Data.Map.Internal.Tip Data.Map.Internal.Tip)-              name = \(!ok) (!inp) (!koByLabel) ->-                name-                  ( let _ = "suspend"-                     in \farInp farExp v (!inp) ->-                          let join = \farInp farExp v (!inp) ->-                                let _ = "resume"-                                 in ok-                                      farInp-                                      farExp-                                      ( let _ = "resume.genCode"-                                         in v-                                      )-                                      inp-                           in let _ = "catch ExceptionFailure"-                               in let catchHandler (!_exn) (!failInp) (!farInp) (!farExp) =-                                        let _ = "catch.ko ExceptionFailure"-                                         in if ( \( Data.Text.Internal.Text-                                                      _-                                                      i-                                                      _-                                                    )-                                                  ( Data.Text.Internal.Text-                                                      _-                                                      j-                                                      _-                                                    ) -> i GHC.Classes.== j-                                               )-                                              inp-                                              failInp-                                              then-                                                let _ = "choicesBranch.then"-                                                 in name-                                                      ( let _ = "suspend"-                                                         in \farInp farExp v (!inp) ->-                                                              let _ = "resume"-                                                               in join-                                                                    farInp-                                                                    farExp-                                                                    ( let _ = "resume.genCode"-                                                                       in v-                                                                    )-                                                                    inp-                                                      )-                                                      failInp-                                                      Data.Map.Internal.Tip-                                              else-                                                let _ = "choicesBranch.else"-                                                 in Data.Map.Strict.Internal.findWithDefault finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure koByLabel Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp farInp farExp-                                   in name-                                        ( let _ = "suspend"-                                           in \farInp farExp v (!inp) ->-                                                let _ = "resume"-                                                 in join-                                                      farInp-                                                      farExp-                                                      ( let _ = "resume.genCode"-                                                         in GHC.Tuple . ()-                                                      )-                                                      inp-                                        )-                                        inp-                                        (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure catchHandler Data.Map.Internal.Tip Data.Map.Internal.Tip)-                  )-                  inp-                  (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure (Data.Map.Strict.Internal.findWithDefault finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure koByLabel) Data.Map.Internal.Tip Data.Map.Internal.Tip)-              name = \(!ok) (!inp) (!koByLabel) ->-                let readFail = Data.Map.Strict.Internal.findWithDefault finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure koByLabel-                 in if readMore inp-                      then-                        let !(#-                               c,-                               cs-                               #) = readNext inp-                         in if GHC.Unicode.isSpace c-                              then-                                name-                                  ( let _ = "suspend"-                                     in \farInp farExp v (!inp) ->-                                          let _ = "resume"-                                           in ok-                                                farInp-                                                farExp-                                                ( let _ = "resume.genCode"-                                                   in v-                                                )-                                                inp-                                  )-                                  cs-                                  Data.Map.Internal.Tip-                              else-                                let _ = "checkToken.else"-                                 in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure inp init Data.Set.Internal.empty-                      else-                        let _ = "checkHorizon.else"-                         in let failExp =-                                  Data.Set.Internal.Bin-                                    1-                                    ( Symantic.Parser.Grammar.Combinators.SomeFailure-                                        ( case inputToken of-                                            (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureHorizon @tok' 1-                                        )-                                    )-                                    Data.Set.Internal.Tip-                                    Data.Set.Internal.Tip-                             in let (#-                                      farInp,-                                      farExp-                                      #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init inp of-                                        GHC.Types.LT ->-                                          (#-                                            inp,-                                            failExp-                                          #)-                                        GHC.Types.EQ ->-                                          (#-                                            init,-                                            failExp GHC.Base.<> Data.Set.Internal.empty-                                          #)-                                        GHC.Types.GT ->-                                          (#-                                            init,-                                            Data.Set.Internal.empty-                                          #)-                                 in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp-              name = \(!ok) (!inp) (!koByLabel) ->-                let readFail = Data.Map.Strict.Internal.findWithDefault finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure koByLabel-                 in if readMore inp-                      then-                        let !(#-                               c,-                               cs-                               #) = readNext inp-                         in if (\t -> ('0' GHC.Classes.== t) GHC.Classes.|| (('1' GHC.Classes.== t) GHC.Classes.|| (('2' GHC.Classes.== t) GHC.Classes.|| (('3' GHC.Classes.== t) GHC.Classes.|| (('4' GHC.Classes.== t) GHC.Classes.|| (('5' GHC.Classes.== t) GHC.Classes.|| (('6' GHC.Classes.== t) GHC.Classes.|| (('7' GHC.Classes.== t) GHC.Classes.|| (('8' GHC.Classes.== t) GHC.Classes.|| (('9' GHC.Classes.== t) GHC.Classes.|| GHC.Types.False)))))))))) c-                              then-                                let _ = "resume"-                                 in ok-                                      init-                                      Data.Set.Internal.empty-                                      ( let _ = "resume.genCode"-                                         in c-                                      )-                                      cs-                              else-                                let _ = "checkToken.else"-                                 in let failExp =-                                          Data.Set.Internal.Bin-                                            10-                                            ( Symantic.Parser.Grammar.Combinators.SomeFailure-                                                ( case inputToken of-                                                    (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken '3'-                                                )-                                            )-                                            ( Data.Set.Internal.Bin-                                                3-                                                ( Symantic.Parser.Grammar.Combinators.SomeFailure-                                                    ( case inputToken of-                                                        (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken '1'-                                                    )-                                                )-                                                ( Data.Set.Internal.Bin-                                                    1-                                                    ( Symantic.Parser.Grammar.Combinators.SomeFailure-                                                        ( case inputToken of-                                                            (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken '0'-                                                        )-                                                    )-                                                    Data.Set.Internal.Tip-                                                    Data.Set.Internal.Tip-                                                )-                                                ( Data.Set.Internal.Bin-                                                    1-                                                    ( Symantic.Parser.Grammar.Combinators.SomeFailure-                                                        ( case inputToken of-                                                            (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken '2'-                                                        )-                                                    )-                                                    Data.Set.Internal.Tip-                                                    Data.Set.Internal.Tip-                                                )-                                            )-                                            ( Data.Set.Internal.Bin-                                                6-                                                ( Symantic.Parser.Grammar.Combinators.SomeFailure-                                                    ( case inputToken of-                                                        (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken '7'-                                                    )-                                                )-                                                ( Data.Set.Internal.Bin-                                                    3-                                                    ( Symantic.Parser.Grammar.Combinators.SomeFailure-                                                        ( case inputToken of-                                                            (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken '5'-                                                        )-                                                    )-                                                    ( Data.Set.Internal.Bin-                                                        1-                                                        ( Symantic.Parser.Grammar.Combinators.SomeFailure-                                                            ( case inputToken of-                                                                (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken '4'-                                                            )-                                                        )-                                                        Data.Set.Internal.Tip-                                                        Data.Set.Internal.Tip-                                                    )-                                                    ( Data.Set.Internal.Bin-                                                        1-                                                        ( Symantic.Parser.Grammar.Combinators.SomeFailure-                                                            ( case inputToken of-                                                                (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken '6'-                                                            )-                                                        )-                                                        Data.Set.Internal.Tip-                                                        Data.Set.Internal.Tip-                                                    )-                                                )-                                                ( Data.Set.Internal.Bin-                                                    2-                                                    ( Symantic.Parser.Grammar.Combinators.SomeFailure-                                                        ( case inputToken of-                                                            (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken '8'-                                                        )-                                                    )-                                                    Data.Set.Internal.Tip-                                                    ( Data.Set.Internal.Bin-                                                        1-                                                        ( Symantic.Parser.Grammar.Combinators.SomeFailure-                                                            ( case inputToken of-                                                                (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken '9'-                                                            )-                                                        )-                                                        Data.Set.Internal.Tip-                                                        Data.Set.Internal.Tip-                                                    )-                                                )-                                            )-                                     in let (#-                                              farInp,-                                              farExp-                                              #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init inp of-                                                GHC.Types.LT ->-                                                  (#-                                                    inp,-                                                    failExp-                                                  #)-                                                GHC.Types.EQ ->-                                                  (#-                                                    init,-                                                    failExp GHC.Base.<> Data.Set.Internal.empty-                                                  #)-                                                GHC.Types.GT ->-                                                  (#-                                                    init,-                                                    Data.Set.Internal.empty-                                                  #)-                                         in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp-                      else-                        let _ = "checkHorizon.else"-                         in let failExp =-                                  Data.Set.Internal.Bin-                                    1-                                    ( Symantic.Parser.Grammar.Combinators.SomeFailure-                                        ( case inputToken of-                                            (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureHorizon @tok' 1-                                        )-                                    )-                                    Data.Set.Internal.Tip-                                    Data.Set.Internal.Tip-                             in let (#-                                      farInp,-                                      farExp-                                      #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init inp of-                                        GHC.Types.LT ->-                                          (#-                                            inp,-                                            failExp-                                          #)-                                        GHC.Types.EQ ->-                                          (#-                                            init,-                                            failExp GHC.Base.<> Data.Set.Internal.empty-                                          #)-                                        GHC.Types.GT ->-                                          (#-                                            init,-                                            Data.Set.Internal.empty-                                          #)-                                 in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp-              name = \(!ok) (!inp) (!koByLabel) ->-                let readFail = Data.Map.Strict.Internal.findWithDefault finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure koByLabel-                 in if readMore (Symantic.Parser.Machine.Input.shiftRightText 1 inp)-                      then-                        let !(#-                               c,-                               cs-                               #) = readNext inp-                         in if (GHC.Classes.==) '(' c-                              then-                                name-                                  ( let _ = "suspend"-                                     in \farInp farExp v (!inp) ->-                                          let _ = "resume"-                                           in ok-                                                farInp-                                                farExp-                                                ( let _ = "resume.genCode"-                                                   in '('-                                                )-                                                inp-                                  )-                                  cs-                                  (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure readFail Data.Map.Internal.Tip Data.Map.Internal.Tip)-                              else-                                let _ = "checkToken.else"-                                 in let failExp =-                                          Data.Set.Internal.Bin-                                            1-                                            ( Symantic.Parser.Grammar.Combinators.SomeFailure-                                                ( case inputToken of-                                                    (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken '('-                                                )-                                            )-                                            Data.Set.Internal.Tip-                                            Data.Set.Internal.Tip-                                     in let (#-                                              farInp,-                                              farExp-                                              #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init inp of-                                                GHC.Types.LT ->-                                                  (#-                                                    inp,-                                                    failExp-                                                  #)-                                                GHC.Types.EQ ->-                                                  (#-                                                    init,-                                                    failExp GHC.Base.<> Data.Set.Internal.empty-                                                  #)-                                                GHC.Types.GT ->-                                                  (#-                                                    init,-                                                    Data.Set.Internal.empty-                                                  #)-                                         in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp-                      else-                        let _ = "checkHorizon.else"-                         in let failExp =-                                  Data.Set.Internal.Bin-                                    1-                                    ( Symantic.Parser.Grammar.Combinators.SomeFailure-                                        ( case inputToken of-                                            (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureHorizon @tok' 2-                                        )-                                    )-                                    Data.Set.Internal.Tip-                                    Data.Set.Internal.Tip-                             in let (#-                                      farInp,-                                      farExp-                                      #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init inp of-                                        GHC.Types.LT ->-                                          (#-                                            inp,-                                            failExp-                                          #)-                                        GHC.Types.EQ ->-                                          (#-                                            init,-                                            failExp GHC.Base.<> Data.Set.Internal.empty-                                          #)-                                        GHC.Types.GT ->-                                          (#-                                            init,-                                            Data.Set.Internal.empty-                                          #)-                                 in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp-              name = \(!ok) (!inp) (!koByLabel) ->-                let readFail = Data.Map.Strict.Internal.findWithDefault finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure koByLabel-                 in if readMore (Symantic.Parser.Machine.Input.shiftRightText 1 inp)-                      then-                        let !(#-                               c,-                               cs-                               #) = readNext inp-                         in if (GHC.Classes.==) ')' c-                              then-                                name-                                  ( let _ = "suspend"-                                     in \farInp farExp v (!inp) ->-                                          let _ = "resume"-                                           in ok-                                                farInp-                                                farExp-                                                ( let _ = "resume.genCode"-                                                   in ')'-                                                )-                                                inp-                                  )-                                  cs-                                  (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure readFail Data.Map.Internal.Tip Data.Map.Internal.Tip)-                              else-                                let _ = "checkToken.else"-                                 in let failExp =-                                          Data.Set.Internal.Bin-                                            1-                                            ( Symantic.Parser.Grammar.Combinators.SomeFailure-                                                ( case inputToken of-                                                    (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken ')'-                                                )-                                            )-                                            Data.Set.Internal.Tip-                                            Data.Set.Internal.Tip-                                     in let (#-                                              farInp,-                                              farExp-                                              #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init inp of-                                                GHC.Types.LT ->-                                                  (#-                                                    inp,-                                                    failExp-                                                  #)-                                                GHC.Types.EQ ->-                                                  (#-                                                    init,-                                                    failExp GHC.Base.<> Data.Set.Internal.empty-                                                  #)-                                                GHC.Types.GT ->-                                                  (#-                                                    init,-                                                    Data.Set.Internal.empty-                                                  #)-                                         in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp-                      else-                        let _ = "checkHorizon.else"-                         in let failExp =-                                  Data.Set.Internal.Bin-                                    1-                                    ( Symantic.Parser.Grammar.Combinators.SomeFailure-                                        ( case inputToken of-                                            (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureHorizon @tok' 2-                                        )-                                    )-                                    Data.Set.Internal.Tip-                                    Data.Set.Internal.Tip-                             in let (#-                                      farInp,-                                      farExp-                                      #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init inp of-                                        GHC.Types.LT ->-                                          (#-                                            inp,-                                            failExp-                                          #)-                                        GHC.Types.EQ ->-                                          (#-                                            init,-                                            failExp GHC.Base.<> Data.Set.Internal.empty-                                          #)-                                        GHC.Types.GT ->-                                          (#-                                            init,-                                            Data.Set.Internal.empty-                                          #)-                                 in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp-              name = \(!ok) (!inp) (!koByLabel) ->-                let readFail = Data.Map.Strict.Internal.findWithDefault finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure koByLabel-                 in if readMore (Symantic.Parser.Machine.Input.shiftRightText 1 inp)-                      then-                        let !(#-                               c,-                               cs-                               #) = readNext inp-                         in if (GHC.Classes.==) ',' c-                              then-                                name-                                  ( let _ = "suspend"-                                     in \farInp farExp v (!inp) ->-                                          let _ = "resume"-                                           in ok-                                                farInp-                                                farExp-                                                ( let _ = "resume.genCode"-                                                   in ','-                                                )-                                                inp-                                  )-                                  cs-                                  (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure readFail Data.Map.Internal.Tip Data.Map.Internal.Tip)-                              else-                                let _ = "checkToken.else"-                                 in let failExp =-                                          Data.Set.Internal.Bin-                                            1-                                            ( Symantic.Parser.Grammar.Combinators.SomeFailure-                                                ( case inputToken of-                                                    (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken ','-                                                )-                                            )-                                            Data.Set.Internal.Tip-                                            Data.Set.Internal.Tip-                                     in let (#-                                              farInp,-                                              farExp-                                              #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init inp of-                                                GHC.Types.LT ->-                                                  (#-                                                    inp,-                                                    failExp-                                                  #)-                                                GHC.Types.EQ ->-                                                  (#-                                                    init,-                                                    failExp GHC.Base.<> Data.Set.Internal.empty-                                                  #)-                                                GHC.Types.GT ->-                                                  (#-                                                    init,-                                                    Data.Set.Internal.empty-                                                  #)-                                         in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp-                      else-                        let _ = "checkHorizon.else"-                         in let failExp =-                                  Data.Set.Internal.Bin-                                    1-                                    ( Symantic.Parser.Grammar.Combinators.SomeFailure-                                        ( case inputToken of-                                            (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureHorizon @tok' 2-                                        )-                                    )-                                    Data.Set.Internal.Tip-                                    Data.Set.Internal.Tip-                             in let (#-                                      farInp,-                                      farExp-                                      #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init inp of-                                        GHC.Types.LT ->-                                          (#-                                            inp,-                                            failExp-                                          #)-                                        GHC.Types.EQ ->-                                          (#-                                            init,-                                            failExp GHC.Base.<> Data.Set.Internal.empty-                                          #)-                                        GHC.Types.GT ->-                                          (#-                                            init,-                                            Data.Set.Internal.empty-                                          #)-                                 in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp-              name = \(!ok) (!inp) (!koByLabel) ->-                let readFail = Data.Map.Strict.Internal.findWithDefault finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure koByLabel-                 in if readMore (Symantic.Parser.Machine.Input.shiftRightText 1 inp)-                      then-                        let !(#-                               c,-                               cs-                               #) = readNext inp-                         in if (GHC.Classes.==) ';' c-                              then-                                name-                                  ( let _ = "suspend"-                                     in \farInp farExp v (!inp) ->-                                          let _ = "resume"-                                           in ok-                                                farInp-                                                farExp-                                                ( let _ = "resume.genCode"-                                                   in ';'-                                                )-                                                inp-                                  )-                                  cs-                                  (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure readFail Data.Map.Internal.Tip Data.Map.Internal.Tip)-                              else-                                let _ = "checkToken.else"-                                 in let failExp =-                                          Data.Set.Internal.Bin-                                            1-                                            ( Symantic.Parser.Grammar.Combinators.SomeFailure-                                                ( case inputToken of-                                                    (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken ';'-                                                )-                                            )-                                            Data.Set.Internal.Tip-                                            Data.Set.Internal.Tip-                                     in let (#-                                              farInp,-                                              farExp-                                              #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init inp of-                                                GHC.Types.LT ->-                                                  (#-                                                    inp,-                                                    failExp-                                                  #)-                                                GHC.Types.EQ ->-                                                  (#-                                                    init,-                                                    failExp GHC.Base.<> Data.Set.Internal.empty-                                                  #)-                                                GHC.Types.GT ->-                                                  (#-                                                    init,-                                                    Data.Set.Internal.empty-                                                  #)-                                         in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp-                      else-                        let _ = "checkHorizon.else"-                         in let failExp =-                                  Data.Set.Internal.Bin-                                    1-                                    ( Symantic.Parser.Grammar.Combinators.SomeFailure-                                        ( case inputToken of-                                            (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureHorizon @tok' 2-                                        )-                                    )-                                    Data.Set.Internal.Tip-                                    Data.Set.Internal.Tip-                             in let (#-                                      farInp,-                                      farExp-                                      #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init inp of-                                        GHC.Types.LT ->-                                          (#-                                            inp,-                                            failExp-                                          #)-                                        GHC.Types.EQ ->-                                          (#-                                            init,-                                            failExp GHC.Base.<> Data.Set.Internal.empty-                                          #)-                                        GHC.Types.GT ->-                                          (#-                                            init,-                                            Data.Set.Internal.empty-                                          #)-                                 in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp-              name = \(!ok) (!inp) (!koByLabel) ->-                let readFail = Data.Map.Strict.Internal.findWithDefault finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure koByLabel-                 in if readMore (Symantic.Parser.Machine.Input.shiftRightText 3 inp)-                      then-                        let !(#-                               c,-                               cs-                               #) = readNext inp-                         in if (GHC.Classes.==) '{' c-                              then-                                name-                                  ( let _ = "suspend"-                                     in \farInp farExp v (!inp) ->-                                          name-                                            ( let _ = "suspend"-                                               in \farInp farExp v (!inp) ->-                                                    name-                                                      ( let _ = "suspend"-                                                         in \farInp farExp v (!inp) ->-                                                              name-                                                                ( let _ = "suspend"-                                                                   in \farInp farExp v (!inp) ->-                                                                        let readFail = readFail-                                                                         in if readMore inp-                                                                              then-                                                                                let !(#-                                                                                       c,-                                                                                       cs-                                                                                       #) = readNext inp-                                                                                 in if (GHC.Classes.==) '}' c-                                                                                      then-                                                                                        name-                                                                                          ( let _ = "suspend"-                                                                                             in \farInp farExp v (!inp) ->-                                                                                                  let _ = "resume"-                                                                                                   in ok-                                                                                                        farInp-                                                                                                        farExp-                                                                                                        ( let _ = "resume.genCode"-                                                                                                           in v-                                                                                                        )-                                                                                                        inp-                                                                                          )-                                                                                          cs-                                                                                          (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure readFail Data.Map.Internal.Tip Data.Map.Internal.Tip)-                                                                                      else-                                                                                        let _ = "checkToken.else"-                                                                                         in let failExp =-                                                                                                  Data.Set.Internal.Bin-                                                                                                    1-                                                                                                    ( Symantic.Parser.Grammar.Combinators.SomeFailure-                                                                                                        ( case inputToken of-                                                                                                            (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken '}'-                                                                                                        )-                                                                                                    )-                                                                                                    Data.Set.Internal.Tip-                                                                                                    Data.Set.Internal.Tip-                                                                                             in let (#-                                                                                                      farInp,-                                                                                                      farExp-                                                                                                      #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp inp of-                                                                                                        GHC.Types.LT ->-                                                                                                          (#-                                                                                                            inp,-                                                                                                            failExp-                                                                                                          #)-                                                                                                        GHC.Types.EQ ->-                                                                                                          (#-                                                                                                            farInp,-                                                                                                            failExp GHC.Base.<> farExp-                                                                                                          #)-                                                                                                        GHC.Types.GT ->-                                                                                                          (#-                                                                                                            farInp,-                                                                                                            farExp-                                                                                                          #)-                                                                                                 in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp-                                                                              else-                                                                                let _ = "checkHorizon.else"-                                                                                 in let failExp =-                                                                                          Data.Set.Internal.Bin-                                                                                            1-                                                                                            ( Symantic.Parser.Grammar.Combinators.SomeFailure-                                                                                                ( case inputToken of-                                                                                                    (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureHorizon @tok' 1-                                                                                                )-                                                                                            )-                                                                                            Data.Set.Internal.Tip-                                                                                            Data.Set.Internal.Tip-                                                                                     in let (#-                                                                                              farInp,-                                                                                              farExp-                                                                                              #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp inp of-                                                                                                GHC.Types.LT ->-                                                                                                  (#-                                                                                                    inp,-                                                                                                    failExp-                                                                                                  #)-                                                                                                GHC.Types.EQ ->-                                                                                                  (#-                                                                                                    farInp,-                                                                                                    failExp GHC.Base.<> farExp-                                                                                                  #)-                                                                                                GHC.Types.GT ->-                                                                                                  (#-                                                                                                    farInp,-                                                                                                    farExp-                                                                                                  #)-                                                                                         in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp-                                                                )-                                                                inp-                                                                Data.Map.Internal.Tip-                                                      )-                                                      inp-                                                      (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure readFail Data.Map.Internal.Tip Data.Map.Internal.Tip)-                                            )-                                            inp-                                            Data.Map.Internal.Tip-                                  )-                                  cs-                                  (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure readFail Data.Map.Internal.Tip Data.Map.Internal.Tip)-                              else-                                let _ = "checkToken.else"-                                 in let failExp =-                                          Data.Set.Internal.Bin-                                            1-                                            ( Symantic.Parser.Grammar.Combinators.SomeFailure-                                                ( case inputToken of-                                                    (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken '{'-                                                )-                                            )-                                            Data.Set.Internal.Tip-                                            Data.Set.Internal.Tip-                                     in let (#-                                              farInp,-                                              farExp-                                              #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init inp of-                                                GHC.Types.LT ->-                                                  (#-                                                    inp,-                                                    failExp-                                                  #)-                                                GHC.Types.EQ ->-                                                  (#-                                                    init,-                                                    failExp GHC.Base.<> Data.Set.Internal.empty-                                                  #)-                                                GHC.Types.GT ->-                                                  (#-                                                    init,-                                                    Data.Set.Internal.empty-                                                  #)-                                         in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp-                      else-                        let _ = "checkHorizon.else"-                         in let failExp =-                                  Data.Set.Internal.Bin-                                    1-                                    ( Symantic.Parser.Grammar.Combinators.SomeFailure-                                        ( case inputToken of-                                            (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureHorizon @tok' 4-                                        )-                                    )-                                    Data.Set.Internal.Tip-                                    Data.Set.Internal.Tip-                             in let (#-                                      farInp,-                                      farExp-                                      #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init inp of-                                        GHC.Types.LT ->-                                          (#-                                            inp,-                                            failExp-                                          #)-                                        GHC.Types.EQ ->-                                          (#-                                            init,-                                            failExp GHC.Base.<> Data.Set.Internal.empty-                                          #)-                                        GHC.Types.GT ->-                                          (#-                                            init,-                                            Data.Set.Internal.empty-                                          #)-                                 in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp-              name = \(!ok) (!inp) (!koByLabel) ->-                let readFail = Data.Map.Strict.Internal.findWithDefault finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure koByLabel-                 in if readMore (Symantic.Parser.Machine.Input.shiftRightText 4 inp)-                      then-                        let !(#-                               c,-                               cs-                               #) = readNext inp-                         in if (GHC.Classes.==) '[' c-                              then-                                name-                                  ( let _ = "suspend"-                                     in \farInp farExp v (!inp) ->-                                          name-                                            ( let _ = "suspend"-                                               in \farInp farExp v (!inp) ->-                                                    name-                                                      ( let _ = "suspend"-                                                         in \farInp farExp v (!inp) ->-                                                              let readFail = readFail-                                                               in if readMore inp-                                                                    then-                                                                      let !(#-                                                                             c,-                                                                             cs-                                                                             #) = readNext inp-                                                                       in if (GHC.Classes.==) ']' c-                                                                            then-                                                                              name-                                                                                ( let _ = "suspend"-                                                                                   in \farInp farExp v (!inp) ->-                                                                                        let _ = "resume"-                                                                                         in ok-                                                                                              farInp-                                                                                              farExp-                                                                                              ( let _ = "resume.genCode"-                                                                                                 in GHC.Tuple . ()-                                                                                              )-                                                                                              inp-                                                                                )-                                                                                cs-                                                                                (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure readFail Data.Map.Internal.Tip Data.Map.Internal.Tip)-                                                                            else-                                                                              let _ = "checkToken.else"-                                                                               in let failExp =-                                                                                        Data.Set.Internal.Bin-                                                                                          1-                                                                                          ( Symantic.Parser.Grammar.Combinators.SomeFailure-                                                                                              ( case inputToken of-                                                                                                  (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken ']'-                                                                                              )-                                                                                          )-                                                                                          Data.Set.Internal.Tip-                                                                                          Data.Set.Internal.Tip-                                                                                   in let (#-                                                                                            farInp,-                                                                                            farExp-                                                                                            #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp inp of-                                                                                              GHC.Types.LT ->-                                                                                                (#-                                                                                                  inp,-                                                                                                  failExp-                                                                                                #)-                                                                                              GHC.Types.EQ ->-                                                                                                (#-                                                                                                  farInp,-                                                                                                  failExp GHC.Base.<> farExp-                                                                                                #)-                                                                                              GHC.Types.GT ->-                                                                                                (#-                                                                                                  farInp,-                                                                                                  farExp-                                                                                                #)-                                                                                       in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp-                                                                    else-                                                                      let _ = "checkHorizon.else"-                                                                       in let failExp =-                                                                                Data.Set.Internal.Bin-                                                                                  1-                                                                                  ( Symantic.Parser.Grammar.Combinators.SomeFailure-                                                                                      ( case inputToken of-                                                                                          (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureHorizon @tok' 1-                                                                                      )-                                                                                  )-                                                                                  Data.Set.Internal.Tip-                                                                                  Data.Set.Internal.Tip-                                                                           in let (#-                                                                                    farInp,-                                                                                    farExp-                                                                                    #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp inp of-                                                                                      GHC.Types.LT ->-                                                                                        (#-                                                                                          inp,-                                                                                          failExp-                                                                                        #)-                                                                                      GHC.Types.EQ ->-                                                                                        (#-                                                                                          farInp,-                                                                                          failExp GHC.Base.<> farExp-                                                                                        #)-                                                                                      GHC.Types.GT ->-                                                                                        (#-                                                                                          farInp,-                                                                                          farExp-                                                                                        #)-                                                                               in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp-                                                      )-                                                      inp-                                                      (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure readFail Data.Map.Internal.Tip Data.Map.Internal.Tip)-                                            )-                                            inp-                                            (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure readFail Data.Map.Internal.Tip Data.Map.Internal.Tip)-                                  )-                                  cs-                                  (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure readFail Data.Map.Internal.Tip Data.Map.Internal.Tip)-                              else-                                let _ = "checkToken.else"-                                 in let failExp =-                                          Data.Set.Internal.Bin-                                            1-                                            ( Symantic.Parser.Grammar.Combinators.SomeFailure-                                                ( case inputToken of-                                                    (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken '['-                                                )-                                            )-                                            Data.Set.Internal.Tip-                                            Data.Set.Internal.Tip-                                     in let (#-                                              farInp,-                                              farExp-                                              #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init inp of-                                                GHC.Types.LT ->-                                                  (#-                                                    inp,-                                                    failExp-                                                  #)-                                                GHC.Types.EQ ->-                                                  (#-                                                    init,-                                                    failExp GHC.Base.<> Data.Set.Internal.empty-                                                  #)-                                                GHC.Types.GT ->-                                                  (#-                                                    init,-                                                    Data.Set.Internal.empty-                                                  #)-                                         in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp-                      else-                        let _ = "checkHorizon.else"-                         in let failExp =-                                  Data.Set.Internal.Bin-                                    1-                                    ( Symantic.Parser.Grammar.Combinators.SomeFailure-                                        ( case inputToken of-                                            (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureHorizon @tok' 5-                                        )-                                    )-                                    Data.Set.Internal.Tip-                                    Data.Set.Internal.Tip-                             in let (#-                                      farInp,-                                      farExp-                                      #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init inp of-                                        GHC.Types.LT ->-                                          (#-                                            inp,-                                            failExp-                                          #)-                                        GHC.Types.EQ ->-                                          (#-                                            init,-                                            failExp GHC.Base.<> Data.Set.Internal.empty-                                          #)-                                        GHC.Types.GT ->-                                          (#-                                            init,-                                            Data.Set.Internal.empty-                                          #)-                                 in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp-              name = \(!ok) (!inp) (!koByLabel) ->-                let _ = "catch ExceptionFailure"-                 in let catchHandler (!_exn) (!failInp) (!farInp) (!farExp) =-                          let _ = "catch.ko ExceptionFailure"-                           in Data.Map.Strict.Internal.findWithDefault finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure koByLabel Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp-                     in let readFail = catchHandler-                         in if readMore (Symantic.Parser.Machine.Input.shiftRightText 1 inp)-                              then-                                let !(#-                                       c,-                                       cs-                                       #) = readNext inp-                                 in if Parsers.Nandlang.nandIdentStart c-                                      then-                                        name-                                          ( let _ = "suspend"-                                             in \farInp farExp v (!inp) ->-                                                  name-                                                    ( let _ = "suspend"-                                                       in \farInp farExp v (!inp) ->-                                                            name-                                                              ( let _ = "suspend"-                                                                 in \farInp farExp v (!inp) ->-                                                                      name-                                                                        ( let _ = "suspend"-                                                                           in \farInp farExp v (!inp) ->-                                                                                let _ = "resume"-                                                                                 in ok-                                                                                      farInp-                                                                                      farExp-                                                                                      ( let _ = "resume.genCode"-                                                                                         in v-                                                                                      )-                                                                                      inp-                                                                        )-                                                                        inp-                                                                        (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure (Data.Map.Strict.Internal.findWithDefault finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure koByLabel) Data.Map.Internal.Tip Data.Map.Internal.Tip)-                                                              )-                                                              inp-                                                              Data.Map.Internal.Tip-                                                    )-                                                    inp-                                                    (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure readFail Data.Map.Internal.Tip Data.Map.Internal.Tip)-                                          )-                                          cs-                                          Data.Map.Internal.Tip-                                      else-                                        let _ = "checkToken.else"-                                         in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure inp init Data.Set.Internal.empty-                              else-                                let _ = "checkHorizon.else"-                                 in let failExp =-                                          Data.Set.Internal.Bin-                                            1-                                            ( Symantic.Parser.Grammar.Combinators.SomeFailure-                                                ( case inputToken of-                                                    (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureHorizon @tok' 2-                                                )-                                            )-                                            Data.Set.Internal.Tip-                                            Data.Set.Internal.Tip-                                     in let (#-                                              farInp,-                                              farExp-                                              #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init inp of-                                                GHC.Types.LT ->-                                                  (#-                                                    inp,-                                                    failExp-                                                  #)-                                                GHC.Types.EQ ->-                                                  (#-                                                    init,-                                                    failExp GHC.Base.<> Data.Set.Internal.empty-                                                  #)-                                                GHC.Types.GT ->-                                                  (#-                                                    init,-                                                    Data.Set.Internal.empty-                                                  #)-                                         in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp-              name = \(!ok) (!inp) (!koByLabel) ->-                let _ = "catch ExceptionFailure"-                 in let catchHandler (!_exn) (!failInp) (!farInp) (!farExp) =-                          let _ = "catch.ko ExceptionFailure"-                           in if ( \( Data.Text.Internal.Text-                                        _-                                        i-                                        _-                                      )-                                    ( Data.Text.Internal.Text-                                        _-                                        j-                                        _-                                      ) -> i GHC.Classes.== j-                                 )-                                inp-                                failInp-                                then-                                  let _ = "choicesBranch.then"-                                   in name-                                        ( let _ = "suspend"-                                           in \farInp farExp v (!inp) ->-                                                let join = \farInp farExp v (!inp) ->-                                                      let _ = "resume"-                                                       in ok-                                                            farInp-                                                            farExp-                                                            ( let _ = "resume.genCode"-                                                               in v-                                                            )-                                                            inp-                                                 in let _ = "catch ExceptionFailure"-                                                     in let catchHandler (!_exn) (!failInp) (!farInp) (!farExp) =-                                                              let _ = "catch.ko ExceptionFailure"-                                                               in if ( \( Data.Text.Internal.Text-                                                                            _-                                                                            i-                                                                            _-                                                                          )-                                                                        ( Data.Text.Internal.Text-                                                                            _-                                                                            j-                                                                            _-                                                                          ) -> i GHC.Classes.== j-                                                                     )-                                                                    inp-                                                                    failInp-                                                                    then-                                                                      let _ = "choicesBranch.then"-                                                                       in name-                                                                            ( let _ = "suspend"-                                                                               in \farInp farExp v (!inp) ->-                                                                                    let _ = "resume"-                                                                                     in join-                                                                                          farInp-                                                                                          farExp-                                                                                          ( let _ = "resume.genCode"-                                                                                             in v-                                                                                          )-                                                                                          inp-                                                                            )-                                                                            failInp-                                                                            Data.Map.Internal.Tip-                                                                    else-                                                                      let _ = "choicesBranch.else"-                                                                       in Data.Map.Strict.Internal.findWithDefault finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure koByLabel Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp farInp farExp-                                                         in let join = \farInp farExp v (!inp) ->-                                                                  let _ = "resume"-                                                                   in join-                                                                        farInp-                                                                        farExp-                                                                        ( let _ = "resume.genCode"-                                                                           in GHC.Tuple . ()-                                                                        )-                                                                        inp-                                                             in let _ = "catch ExceptionFailure"-                                                                 in let catchHandler (!_exn) (!failInp) (!farInp) (!farExp) =-                                                                          let _ = "catch.ko ExceptionFailure"-                                                                           in if ( \( Data.Text.Internal.Text-                                                                                        _-                                                                                        i-                                                                                        _-                                                                                      )-                                                                                    ( Data.Text.Internal.Text-                                                                                        _-                                                                                        j-                                                                                        _-                                                                                      ) -> i GHC.Classes.== j-                                                                                 )-                                                                                inp-                                                                                failInp-                                                                                then-                                                                                  let _ = "choicesBranch.then"-                                                                                   in name-                                                                                        ( let _ = "suspend"-                                                                                           in \farInp farExp v (!inp) ->-                                                                                                let _ = "resume"-                                                                                                 in join-                                                                                                      farInp-                                                                                                      farExp-                                                                                                      ( let _ = "resume.genCode"-                                                                                                         in v-                                                                                                      )-                                                                                                      inp-                                                                                        )-                                                                                        failInp-                                                                                        (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure catchHandler Data.Map.Internal.Tip Data.Map.Internal.Tip)-                                                                                else-                                                                                  let _ = "choicesBranch.else"-                                                                                   in catchHandler Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp farInp farExp-                                                                     in name-                                                                          ( let _ = "suspend"-                                                                             in \farInp farExp v (!inp) ->-                                                                                  let join = \farInp farExp v (!inp) ->-                                                                                        name-                                                                                          ( let _ = "suspend"-                                                                                             in \farInp farExp v (!inp) ->-                                                                                                  let _ = "resume"-                                                                                                   in join-                                                                                                        farInp-                                                                                                        farExp-                                                                                                        ( let _ = "resume.genCode"-                                                                                                           in v-                                                                                                        )-                                                                                                        inp-                                                                                          )-                                                                                          inp-                                                                                          (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure catchHandler Data.Map.Internal.Tip Data.Map.Internal.Tip)-                                                                                   in let _ = "catch ExceptionFailure"-                                                                                       in let catchHandler (!_exn) (!failInp) (!farInp) (!farExp) =-                                                                                                let _ = "catch.ko ExceptionFailure"-                                                                                                 in if ( \( Data.Text.Internal.Text-                                                                                                              _-                                                                                                              i-                                                                                                              _-                                                                                                            )-                                                                                                          ( Data.Text.Internal.Text-                                                                                                              _-                                                                                                              j-                                                                                                              _-                                                                                                            ) -> i GHC.Classes.== j-                                                                                                       )-                                                                                                      inp-                                                                                                      failInp-                                                                                                      then-                                                                                                        let _ = "choicesBranch.then"-                                                                                                         in name-                                                                                                              ( let _ = "suspend"-                                                                                                                 in \farInp farExp v (!inp) ->-                                                                                                                      let _ = "resume"-                                                                                                                       in join-                                                                                                                            farInp-                                                                                                                            farExp-                                                                                                                            ( let _ = "resume.genCode"-                                                                                                                               in v-                                                                                                                            )-                                                                                                                            inp-                                                                                                              )-                                                                                                              failInp-                                                                                                              Data.Map.Internal.Tip-                                                                                                      else-                                                                                                        let _ = "choicesBranch.else"-                                                                                                         in catchHandler Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp farInp farExp-                                                                                           in name-                                                                                                ( let _ = "suspend"-                                                                                                   in \farInp farExp v (!inp) ->-                                                                                                        name-                                                                                                          ( let _ = "suspend"-                                                                                                             in \farInp farExp v (!inp) ->-                                                                                                                  name-                                                                                                                    ( let _ = "suspend"-                                                                                                                       in \farInp farExp v (!inp) ->-                                                                                                                            name-                                                                                                                              ( let _ = "suspend"-                                                                                                                                 in \farInp farExp v (!inp) ->-                                                                                                                                      let _ = "resume"-                                                                                                                                       in join-                                                                                                                                            farInp-                                                                                                                                            farExp-                                                                                                                                            ( let _ = "resume.genCode"-                                                                                                                                               in GHC.Tuple . ()-                                                                                                                                            )-                                                                                                                                            inp-                                                                                                                              )-                                                                                                                              inp-                                                                                                                              Data.Map.Internal.Tip-                                                                                                                    )-                                                                                                                    inp-                                                                                                                    (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure catchHandler Data.Map.Internal.Tip Data.Map.Internal.Tip)-                                                                                                          )-                                                                                                          inp-                                                                                                          Data.Map.Internal.Tip-                                                                                                )-                                                                                                inp-                                                                                                (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure catchHandler Data.Map.Internal.Tip Data.Map.Internal.Tip)-                                                                          )-                                                                          inp-                                                                          (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure catchHandler Data.Map.Internal.Tip Data.Map.Internal.Tip)-                                        )-                                        failInp-                                        (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure (Data.Map.Strict.Internal.findWithDefault finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure koByLabel) Data.Map.Internal.Tip Data.Map.Internal.Tip)-                                else-                                  let _ = "choicesBranch.else"-                                   in Data.Map.Strict.Internal.findWithDefault finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure koByLabel Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp farInp farExp-                     in let join = \farInp farExp v (!inp) ->-                              let _ = "resume"-                               in ok-                                    farInp-                                    farExp-                                    ( let _ = "resume.genCode"-                                       in v-                                    )-                                    inp-                         in let _ = "catch ExceptionFailure"-                             in let catchHandler (!_exn) (!failInp) (!farInp) (!farExp) =-                                      let _ = "catch.ko ExceptionFailure"-                                       in if ( \( Data.Text.Internal.Text-                                                    _-                                                    i-                                                    _-                                                  )-                                                ( Data.Text.Internal.Text-                                                    _-                                                    j-                                                    _-                                                  ) -> i GHC.Classes.== j-                                             )-                                            inp-                                            failInp-                                            then-                                              let _ = "choicesBranch.then"-                                               in let readFail = catchHandler-                                                   in if readMore (Symantic.Parser.Machine.Input.shiftRightText 3 failInp)-                                                        then-                                                          let !(#-                                                                 c,-                                                                 cs-                                                                 #) = readNext failInp-                                                           in if (GHC.Classes.==) '\'' c-                                                                then-                                                                  let join = \farInp farExp v (!inp) ->-                                                                        let readFail = readFail-                                                                         in if readMore (Symantic.Parser.Machine.Input.shiftRightText 1 inp)-                                                                              then-                                                                                let !(#-                                                                                       c,-                                                                                       cs-                                                                                       #) = readNext inp-                                                                                 in if (GHC.Classes.==) '\'' c-                                                                                      then-                                                                                        name-                                                                                          ( let _ = "suspend"-                                                                                             in \farInp farExp v (!inp) ->-                                                                                                  let _ = "resume"-                                                                                                   in join-                                                                                                        farInp-                                                                                                        farExp-                                                                                                        ( let _ = "resume.genCode"-                                                                                                           in v-                                                                                                        )-                                                                                                        inp-                                                                                          )-                                                                                          cs-                                                                                          (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure readFail Data.Map.Internal.Tip Data.Map.Internal.Tip)-                                                                                      else-                                                                                        let _ = "checkToken.else"-                                                                                         in let failExp =-                                                                                                  Data.Set.Internal.Bin-                                                                                                    1-                                                                                                    ( Symantic.Parser.Grammar.Combinators.SomeFailure-                                                                                                        ( case inputToken of-                                                                                                            (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken '\''-                                                                                                        )-                                                                                                    )-                                                                                                    Data.Set.Internal.Tip-                                                                                                    Data.Set.Internal.Tip-                                                                                             in let (#-                                                                                                      farInp,-                                                                                                      farExp-                                                                                                      #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp inp of-                                                                                                        GHC.Types.LT ->-                                                                                                          (#-                                                                                                            inp,-                                                                                                            failExp-                                                                                                          #)-                                                                                                        GHC.Types.EQ ->-                                                                                                          (#-                                                                                                            farInp,-                                                                                                            failExp GHC.Base.<> farExp-                                                                                                          #)-                                                                                                        GHC.Types.GT ->-                                                                                                          (#-                                                                                                            farInp,-                                                                                                            farExp-                                                                                                          #)-                                                                                                 in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp-                                                                              else-                                                                                let _ = "checkHorizon.else"-                                                                                 in let failExp =-                                                                                          Data.Set.Internal.Bin-                                                                                            1-                                                                                            ( Symantic.Parser.Grammar.Combinators.SomeFailure-                                                                                                ( case inputToken of-                                                                                                    (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureHorizon @tok' 2-                                                                                                )-                                                                                            )-                                                                                            Data.Set.Internal.Tip-                                                                                            Data.Set.Internal.Tip-                                                                                     in let (#-                                                                                              farInp,-                                                                                              farExp-                                                                                              #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp inp of-                                                                                                GHC.Types.LT ->-                                                                                                  (#-                                                                                                    inp,-                                                                                                    failExp-                                                                                                  #)-                                                                                                GHC.Types.EQ ->-                                                                                                  (#-                                                                                                    farInp,-                                                                                                    failExp GHC.Base.<> farExp-                                                                                                  #)-                                                                                                GHC.Types.GT ->-                                                                                                  (#-                                                                                                    farInp,-                                                                                                    farExp-                                                                                                  #)-                                                                                         in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp-                                                                   in let _ = "catch ExceptionFailure"-                                                                       in let catchHandler (!_exn) (!failInp) (!farInp) (!farExp) =-                                                                                let _ = "catch.ko ExceptionFailure"-                                                                                 in if ( \( Data.Text.Internal.Text-                                                                                              _-                                                                                              i-                                                                                              _-                                                                                            )-                                                                                          ( Data.Text.Internal.Text-                                                                                              _-                                                                                              j-                                                                                              _-                                                                                            ) -> i GHC.Classes.== j-                                                                                       )-                                                                                      cs-                                                                                      failInp-                                                                                      then-                                                                                        let _ = "choicesBranch.then"-                                                                                         in let readFail = readFail-                                                                                             in if readMore (Symantic.Parser.Machine.Input.shiftRightText 3 failInp)-                                                                                                  then-                                                                                                    let !(#-                                                                                                           c,-                                                                                                           cs-                                                                                                           #) = readNext failInp-                                                                                                     in if (GHC.Classes.==) '\\' c-                                                                                                          then-                                                                                                            let readFail = readFail-                                                                                                             in let !(#-                                                                                                                       c,-                                                                                                                       cs-                                                                                                                       #) = readNext cs-                                                                                                                 in if (\t -> ('0' GHC.Classes.== t) GHC.Classes.|| (('t' GHC.Classes.== t) GHC.Classes.|| (('n' GHC.Classes.== t) GHC.Classes.|| (('v' GHC.Classes.== t) GHC.Classes.|| (('f' GHC.Classes.== t) GHC.Classes.|| (('r' GHC.Classes.== t) GHC.Classes.|| GHC.Types.False)))))) c-                                                                                                                      then-                                                                                                                        name-                                                                                                                          ( let _ = "suspend"-                                                                                                                             in \farInp farExp v (!inp) ->-                                                                                                                                  let _ = "resume"-                                                                                                                                   in join-                                                                                                                                        farInp-                                                                                                                                        farExp-                                                                                                                                        ( let _ = "resume.genCode"-                                                                                                                                           in v-                                                                                                                                        )-                                                                                                                                        inp-                                                                                                                          )-                                                                                                                          cs-                                                                                                                          Data.Map.Internal.Tip-                                                                                                                      else-                                                                                                                        let _ = "checkToken.else"-                                                                                                                         in let failExp =-                                                                                                                                  Data.Set.Internal.Bin-                                                                                                                                    6-                                                                                                                                    ( Symantic.Parser.Grammar.Combinators.SomeFailure-                                                                                                                                        ( case inputToken of-                                                                                                                                            (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken 'n'-                                                                                                                                        )-                                                                                                                                    )-                                                                                                                                    ( Data.Set.Internal.Bin-                                                                                                                                        2-                                                                                                                                        ( Symantic.Parser.Grammar.Combinators.SomeFailure-                                                                                                                                            ( case inputToken of-                                                                                                                                                (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken '0'-                                                                                                                                            )-                                                                                                                                        )-                                                                                                                                        Data.Set.Internal.Tip-                                                                                                                                        ( Data.Set.Internal.Bin-                                                                                                                                            1-                                                                                                                                            ( Symantic.Parser.Grammar.Combinators.SomeFailure-                                                                                                                                                ( case inputToken of-                                                                                                                                                    (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken 'f'-                                                                                                                                                )-                                                                                                                                            )-                                                                                                                                            Data.Set.Internal.Tip-                                                                                                                                            Data.Set.Internal.Tip-                                                                                                                                        )-                                                                                                                                    )-                                                                                                                                    ( Data.Set.Internal.Bin-                                                                                                                                        3-                                                                                                                                        ( Symantic.Parser.Grammar.Combinators.SomeFailure-                                                                                                                                            ( case inputToken of-                                                                                                                                                (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken 't'-                                                                                                                                            )-                                                                                                                                        )-                                                                                                                                        ( Data.Set.Internal.Bin-                                                                                                                                            1-                                                                                                                                            ( Symantic.Parser.Grammar.Combinators.SomeFailure-                                                                                                                                                ( case inputToken of-                                                                                                                                                    (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken 'r'-                                                                                                                                                )-                                                                                                                                            )-                                                                                                                                            Data.Set.Internal.Tip-                                                                                                                                            Data.Set.Internal.Tip-                                                                                                                                        )-                                                                                                                                        ( Data.Set.Internal.Bin-                                                                                                                                            1-                                                                                                                                            ( Symantic.Parser.Grammar.Combinators.SomeFailure-                                                                                                                                                ( case inputToken of-                                                                                                                                                    (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken 'v'-                                                                                                                                                )-                                                                                                                                            )-                                                                                                                                            Data.Set.Internal.Tip-                                                                                                                                            Data.Set.Internal.Tip-                                                                                                                                        )-                                                                                                                                    )-                                                                                                                             in let (#-                                                                                                                                      farInp,-                                                                                                                                      farExp-                                                                                                                                      #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp cs of-                                                                                                                                        GHC.Types.LT ->-                                                                                                                                          (#-                                                                                                                                            cs,-                                                                                                                                            failExp-                                                                                                                                          #)-                                                                                                                                        GHC.Types.EQ ->-                                                                                                                                          (#-                                                                                                                                            farInp,-                                                                                                                                            failExp GHC.Base.<> farExp-                                                                                                                                          #)-                                                                                                                                        GHC.Types.GT ->-                                                                                                                                          (#-                                                                                                                                            farInp,-                                                                                                                                            farExp-                                                                                                                                          #)-                                                                                                                                 in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure cs farInp farExp-                                                                                                          else-                                                                                                            let _ = "checkToken.else"-                                                                                                             in let failExp =-                                                                                                                      Data.Set.Internal.Bin-                                                                                                                        1-                                                                                                                        ( Symantic.Parser.Grammar.Combinators.SomeFailure-                                                                                                                            ( case inputToken of-                                                                                                                                (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken '\\'-                                                                                                                            )-                                                                                                                        )-                                                                                                                        Data.Set.Internal.Tip-                                                                                                                        Data.Set.Internal.Tip-                                                                                                                 in let (#-                                                                                                                          farInp,-                                                                                                                          farExp-                                                                                                                          #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp failInp of-                                                                                                                            GHC.Types.LT ->-                                                                                                                              (#-                                                                                                                                failInp,-                                                                                                                                failExp-                                                                                                                              #)-                                                                                                                            GHC.Types.EQ ->-                                                                                                                              (#-                                                                                                                                farInp,-                                                                                                                                failExp GHC.Base.<> farExp-                                                                                                                              #)-                                                                                                                            GHC.Types.GT ->-                                                                                                                              (#-                                                                                                                                farInp,-                                                                                                                                farExp-                                                                                                                              #)-                                                                                                                     in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp farInp farExp-                                                                                                  else-                                                                                                    let _ = "checkHorizon.else"-                                                                                                     in let failExp =-                                                                                                              Data.Set.Internal.Bin-                                                                                                                1-                                                                                                                ( Symantic.Parser.Grammar.Combinators.SomeFailure-                                                                                                                    ( case inputToken of-                                                                                                                        (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureHorizon @tok' 4-                                                                                                                    )-                                                                                                                )-                                                                                                                Data.Set.Internal.Tip-                                                                                                                Data.Set.Internal.Tip-                                                                                                         in let (#-                                                                                                                  farInp,-                                                                                                                  farExp-                                                                                                                  #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp failInp of-                                                                                                                    GHC.Types.LT ->-                                                                                                                      (#-                                                                                                                        failInp,-                                                                                                                        failExp-                                                                                                                      #)-                                                                                                                    GHC.Types.EQ ->-                                                                                                                      (#-                                                                                                                        farInp,-                                                                                                                        failExp GHC.Base.<> farExp-                                                                                                                      #)-                                                                                                                    GHC.Types.GT ->-                                                                                                                      (#-                                                                                                                        farInp,-                                                                                                                        farExp-                                                                                                                      #)-                                                                                                             in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp farInp farExp-                                                                                      else-                                                                                        let _ = "choicesBranch.else"-                                                                                         in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp farInp farExp-                                                                           in let readFail = catchHandler-                                                                               in let !(#-                                                                                         c,-                                                                                         cs-                                                                                         #) = readNext cs-                                                                                   in if Parsers.Nandlang.nandStringLetter c-                                                                                        then-                                                                                          name-                                                                                            ( let _ = "suspend"-                                                                                               in \farInp farExp v (!inp) ->-                                                                                                    let _ = "resume"-                                                                                                     in join-                                                                                                          farInp-                                                                                                          farExp-                                                                                                          ( let _ = "resume.genCode"-                                                                                                             in v-                                                                                                          )-                                                                                                          inp-                                                                                            )-                                                                                            cs-                                                                                            Data.Map.Internal.Tip-                                                                                        else-                                                                                          let _ = "checkToken.else"-                                                                                           in catchHandler Symantic.Parser.Grammar.Combinators.ExceptionFailure cs farInp farExp-                                                                else-                                                                  let _ = "checkToken.else"-                                                                   in let failExp =-                                                                            Data.Set.Internal.Bin-                                                                              1-                                                                              ( Symantic.Parser.Grammar.Combinators.SomeFailure-                                                                                  ( case inputToken of-                                                                                      (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken '\''-                                                                                  )-                                                                              )-                                                                              Data.Set.Internal.Tip-                                                                              Data.Set.Internal.Tip-                                                                       in let (#-                                                                                farInp,-                                                                                farExp-                                                                                #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp failInp of-                                                                                  GHC.Types.LT ->-                                                                                    (#-                                                                                      failInp,-                                                                                      failExp-                                                                                    #)-                                                                                  GHC.Types.EQ ->-                                                                                    (#-                                                                                      farInp,-                                                                                      failExp GHC.Base.<> farExp-                                                                                    #)-                                                                                  GHC.Types.GT ->-                                                                                    (#-                                                                                      farInp,-                                                                                      farExp-                                                                                    #)-                                                                           in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp farInp farExp-                                                        else-                                                          let _ = "checkHorizon.else"-                                                           in let failExp =-                                                                    Data.Set.Internal.Bin-                                                                      1-                                                                      ( Symantic.Parser.Grammar.Combinators.SomeFailure-                                                                          ( case inputToken of-                                                                              (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureHorizon @tok' 4-                                                                          )-                                                                      )-                                                                      Data.Set.Internal.Tip-                                                                      Data.Set.Internal.Tip-                                                               in let (#-                                                                        farInp,-                                                                        farExp-                                                                        #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp failInp of-                                                                          GHC.Types.LT ->-                                                                            (#-                                                                              failInp,-                                                                              failExp-                                                                            #)-                                                                          GHC.Types.EQ ->-                                                                            (#-                                                                              farInp,-                                                                              failExp GHC.Base.<> farExp-                                                                            #)-                                                                          GHC.Types.GT ->-                                                                            (#-                                                                              farInp,-                                                                              farExp-                                                                            #)-                                                                   in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp farInp farExp-                                            else-                                              let _ = "choicesBranch.else"-                                               in catchHandler Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp farInp farExp-                                 in let join = \farInp farExp v (!inp) ->-                                          name-                                            ( let _ = "suspend"-                                               in \farInp farExp v (!inp) ->-                                                    let _ = "resume"-                                                     in join-                                                          farInp-                                                          farExp-                                                          ( let _ = "resume.genCode"-                                                             in v-                                                          )-                                                          inp-                                            )-                                            inp-                                            (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure catchHandler Data.Map.Internal.Tip Data.Map.Internal.Tip)-                                     in let _ = "catch ExceptionFailure"-                                         in let catchHandler (!_exn) (!failInp) (!farInp) (!farExp) =-                                                  let _ = "catch.ko ExceptionFailure"-                                                   in if ( \( Data.Text.Internal.Text-                                                                _-                                                                i-                                                                _-                                                              )-                                                            ( Data.Text.Internal.Text-                                                                _-                                                                j-                                                                _-                                                              ) -> i GHC.Classes.== j-                                                         )-                                                        inp-                                                        failInp-                                                        then-                                                          let _ = "choicesBranch.then"-                                                           in let readFail = catchHandler-                                                               in if readMore (Symantic.Parser.Machine.Input.shiftRightText 1 failInp)-                                                                    then-                                                                      let !(#-                                                                             c,-                                                                             cs-                                                                             #) = readNext failInp-                                                                       in if (GHC.Classes.==) '1' c-                                                                            then-                                                                              let _ = "resume"-                                                                               in join-                                                                                    farInp-                                                                                    farExp-                                                                                    ( let _ = "resume.genCode"-                                                                                       in '1'-                                                                                    )-                                                                                    cs-                                                                            else-                                                                              let _ = "checkToken.else"-                                                                               in let failExp =-                                                                                        Data.Set.Internal.Bin-                                                                                          1-                                                                                          ( Symantic.Parser.Grammar.Combinators.SomeFailure-                                                                                              ( case inputToken of-                                                                                                  (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken '1'-                                                                                              )-                                                                                          )-                                                                                          Data.Set.Internal.Tip-                                                                                          Data.Set.Internal.Tip-                                                                                   in let (#-                                                                                            farInp,-                                                                                            farExp-                                                                                            #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp failInp of-                                                                                              GHC.Types.LT ->-                                                                                                (#-                                                                                                  failInp,-                                                                                                  failExp-                                                                                                #)-                                                                                              GHC.Types.EQ ->-                                                                                                (#-                                                                                                  farInp,-                                                                                                  failExp GHC.Base.<> farExp-                                                                                                #)-                                                                                              GHC.Types.GT ->-                                                                                                (#-                                                                                                  farInp,-                                                                                                  farExp-                                                                                                #)-                                                                                       in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp farInp farExp-                                                                    else-                                                                      let _ = "checkHorizon.else"-                                                                       in let failExp =-                                                                                Data.Set.Internal.Bin-                                                                                  1-                                                                                  ( Symantic.Parser.Grammar.Combinators.SomeFailure-                                                                                      ( case inputToken of-                                                                                          (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureHorizon @tok' 2-                                                                                      )-                                                                                  )-                                                                                  Data.Set.Internal.Tip-                                                                                  Data.Set.Internal.Tip-                                                                           in let (#-                                                                                    farInp,-                                                                                    farExp-                                                                                    #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp failInp of-                                                                                      GHC.Types.LT ->-                                                                                        (#-                                                                                          failInp,-                                                                                          failExp-                                                                                        #)-                                                                                      GHC.Types.EQ ->-                                                                                        (#-                                                                                          farInp,-                                                                                          failExp GHC.Base.<> farExp-                                                                                        #)-                                                                                      GHC.Types.GT ->-                                                                                        (#-                                                                                          farInp,-                                                                                          farExp-                                                                                        #)-                                                                               in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp farInp farExp-                                                        else-                                                          let _ = "choicesBranch.else"-                                                           in catchHandler Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp farInp farExp-                                             in let readFail = catchHandler-                                                 in if readMore (Symantic.Parser.Machine.Input.shiftRightText 1 inp)-                                                      then-                                                        let !(#-                                                               c,-                                                               cs-                                                               #) = readNext inp-                                                         in if (GHC.Classes.==) '0' c-                                                              then-                                                                let _ = "resume"-                                                                 in join-                                                                      init-                                                                      Data.Set.Internal.empty-                                                                      ( let _ = "resume.genCode"-                                                                         in '0'-                                                                      )-                                                                      cs-                                                              else-                                                                let _ = "checkToken.else"-                                                                 in let failExp =-                                                                          Data.Set.Internal.Bin-                                                                            1-                                                                            ( Symantic.Parser.Grammar.Combinators.SomeFailure-                                                                                ( case inputToken of-                                                                                    (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken '0'-                                                                                )-                                                                            )-                                                                            Data.Set.Internal.Tip-                                                                            Data.Set.Internal.Tip-                                                                     in let (#-                                                                              farInp,-                                                                              farExp-                                                                              #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init inp of-                                                                                GHC.Types.LT ->-                                                                                  (#-                                                                                    inp,-                                                                                    failExp-                                                                                  #)-                                                                                GHC.Types.EQ ->-                                                                                  (#-                                                                                    init,-                                                                                    failExp GHC.Base.<> Data.Set.Internal.empty-                                                                                  #)-                                                                                GHC.Types.GT ->-                                                                                  (#-                                                                                    init,-                                                                                    Data.Set.Internal.empty-                                                                                  #)-                                                                         in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp-                                                      else-                                                        let _ = "checkHorizon.else"-                                                         in let failExp =-                                                                  Data.Set.Internal.Bin-                                                                    1-                                                                    ( Symantic.Parser.Grammar.Combinators.SomeFailure-                                                                        ( case inputToken of-                                                                            (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureHorizon @tok' 2-                                                                        )-                                                                    )-                                                                    Data.Set.Internal.Tip-                                                                    Data.Set.Internal.Tip-                                                             in let (#-                                                                      farInp,-                                                                      farExp-                                                                      #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init inp of-                                                                        GHC.Types.LT ->-                                                                          (#-                                                                            inp,-                                                                            failExp-                                                                          #)-                                                                        GHC.Types.EQ ->-                                                                          (#-                                                                            init,-                                                                            failExp GHC.Base.<> Data.Set.Internal.empty-                                                                          #)-                                                                        GHC.Types.GT ->-                                                                          (#-                                                                            init,-                                                                            Data.Set.Internal.empty-                                                                          #)-                                                                 in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp-              name = \(!ok) (!inp) (!koByLabel) ->-                let _ = "catch ExceptionFailure"-                 in let catchHandler (!_exn) (!failInp) (!farInp) (!farExp) =-                          let _ = "catch.ko ExceptionFailure"-                           in if ( \( Data.Text.Internal.Text-                                        _-                                        i-                                        _-                                      )-                                    ( Data.Text.Internal.Text-                                        _-                                        j-                                        _-                                      ) -> i GHC.Classes.== j-                                 )-                                inp-                                failInp-                                then-                                  let _ = "choicesBranch.then"-                                   in let _ = "jump"-                                       in name ok failInp Data.Map.Internal.Tip-                                else-                                  let _ = "choicesBranch.else"-                                   in Data.Map.Strict.Internal.findWithDefault finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure koByLabel Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp farInp farExp-                     in name-                          ( let _ = "suspend"-                             in \farInp farExp v (!inp) ->-                                  name-                                    ( let _ = "suspend"-                                       in \farInp farExp v (!inp) ->-                                            name-                                              ( let _ = "suspend"-                                                 in \farInp farExp v (!inp) ->-                                                      name-                                                        ( let _ = "suspend"-                                                           in \farInp farExp v (!inp) ->-                                                                let _ = "resume"-                                                                 in ok-                                                                      farInp-                                                                      farExp-                                                                      ( let _ = "resume.genCode"-                                                                         in GHC.Tuple . ()-                                                                      )-                                                                      inp-                                                        )-                                                        inp-                                                        Data.Map.Internal.Tip-                                              )-                                              inp-                                              (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure catchHandler Data.Map.Internal.Tip Data.Map.Internal.Tip)-                                    )-                                    inp-                                    Data.Map.Internal.Tip-                          )-                          inp-                          (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure catchHandler Data.Map.Internal.Tip Data.Map.Internal.Tip)-              name = \(!ok) (!inp) (!koByLabel) ->-                let _ = "catch ExceptionFailure"-                 in let catchHandler (!_exn) (!failInp) (!farInp) (!farExp) =-                          let _ = "catch.ko ExceptionFailure"-                           in if ( \( Data.Text.Internal.Text-                                        _-                                        i-                                        _-                                      )-                                    ( Data.Text.Internal.Text-                                        _-                                        j-                                        _-                                      ) -> i GHC.Classes.== j-                                 )-                                inp-                                failInp-                                then-                                  let _ = "choicesBranch.then"-                                   in let _ = "resume"-                                       in ok-                                            farInp-                                            farExp-                                            ( let _ = "resume.genCode"-                                               in \x -> x-                                            )-                                            failInp-                                else-                                  let _ = "choicesBranch.else"-                                   in Data.Map.Strict.Internal.findWithDefault finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure koByLabel Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp farInp farExp-                     in name-                          ( let _ = "suspend"-                             in \farInp farExp v (!inp) ->-                                  name-                                    ( let _ = "suspend"-                                       in \farInp farExp v (!inp) ->-                                            name-                                              ( let _ = "suspend"-                                                 in \farInp farExp v (!inp) ->-                                                      name-                                                        ( let _ = "suspend"-                                                           in \farInp farExp v (!inp) ->-                                                                let _ = "resume"-                                                                 in ok-                                                                      farInp-                                                                      farExp-                                                                      ( let _ = "resume.genCode"-                                                                         in \x -> v v (v x)-                                                                      )-                                                                      inp-                                                        )-                                                        inp-                                                        (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure catchHandler Data.Map.Internal.Tip Data.Map.Internal.Tip)-                                              )-                                              inp-                                              (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure catchHandler Data.Map.Internal.Tip Data.Map.Internal.Tip)-                                    )-                                    inp-                                    (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure catchHandler Data.Map.Internal.Tip Data.Map.Internal.Tip)-                          )-                          inp-                          Data.Map.Internal.Tip-              name = \(!ok) (!inp) (!koByLabel) ->-                let _ = "catch ExceptionFailure"-                 in let catchHandler (!_exn) (!failInp) (!farInp) (!farExp) =-                          let _ = "catch.ko ExceptionFailure"-                           in if ( \( Data.Text.Internal.Text-                                        _-                                        i-                                        _-                                      )-                                    ( Data.Text.Internal.Text-                                        _-                                        j-                                        _-                                      ) -> i GHC.Classes.== j-                                 )-                                inp-                                failInp-                                then-                                  let _ = "choicesBranch.then"-                                   in let _ = "resume"-                                       in ok-                                            farInp-                                            farExp-                                            ( let _ = "resume.genCode"-                                               in \x -> x-                                            )-                                            failInp-                                else-                                  let _ = "choicesBranch.else"-                                   in Data.Map.Strict.Internal.findWithDefault finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure koByLabel Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp farInp farExp-                     in name-                          ( let _ = "suspend"-                             in \farInp farExp v (!inp) ->-                                  name-                                    ( let _ = "suspend"-                                       in \farInp farExp v (!inp) ->-                                            name-                                              ( let _ = "suspend"-                                                 in \farInp farExp v (!inp) ->-                                                      name-                                                        ( let _ = "suspend"-                                                           in \farInp farExp v (!inp) ->-                                                                let _ = "resume"-                                                                 in ok-                                                                      farInp-                                                                      farExp-                                                                      ( let _ = "resume.genCode"-                                                                         in \x -> v v (v x)-                                                                      )-                                                                      inp-                                                        )-                                                        inp-                                                        (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure catchHandler Data.Map.Internal.Tip Data.Map.Internal.Tip)-                                              )-                                              inp-                                              (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure catchHandler Data.Map.Internal.Tip Data.Map.Internal.Tip)-                                    )-                                    inp-                                    (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure catchHandler Data.Map.Internal.Tip Data.Map.Internal.Tip)-                          )-                          inp-                          Data.Map.Internal.Tip-              name = \(!ok) (!inp) (!koByLabel) ->-                let _ = "catch ExceptionFailure"-                 in let catchHandler (!_exn) (!failInp) (!farInp) (!farExp) =-                          let _ = "catch.ko ExceptionFailure"-                           in if ( \( Data.Text.Internal.Text-                                        _-                                        i-                                        _-                                      )-                                    ( Data.Text.Internal.Text-                                        _-                                        j-                                        _-                                      ) -> i GHC.Classes.== j-                                 )-                                inp-                                failInp-                                then-                                  let _ = "choicesBranch.then"-                                   in let _ = "resume"-                                       in ok-                                            farInp-                                            farExp-                                            ( let _ = "resume.genCode"-                                               in \x -> x-                                            )-                                            failInp-                                else-                                  let _ = "choicesBranch.else"-                                   in Data.Map.Strict.Internal.findWithDefault finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure koByLabel Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp farInp farExp-                     in name-                          ( let _ = "suspend"-                             in \farInp farExp v (!inp) ->-                                  name-                                    ( let _ = "suspend"-                                       in \farInp farExp v (!inp) ->-                                            name-                                              ( let _ = "suspend"-                                                 in \farInp farExp v (!inp) ->-                                                      name-                                                        ( let _ = "suspend"-                                                           in \farInp farExp v (!inp) ->-                                                                let _ = "resume"-                                                                 in ok-                                                                      farInp-                                                                      farExp-                                                                      ( let _ = "resume.genCode"-                                                                         in \x -> v v (v x)-                                                                      )-                                                                      inp-                                                        )-                                                        inp-                                                        (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure catchHandler Data.Map.Internal.Tip Data.Map.Internal.Tip)-                                              )-                                              inp-                                              (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure catchHandler Data.Map.Internal.Tip Data.Map.Internal.Tip)-                                    )-                                    inp-                                    (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure catchHandler Data.Map.Internal.Tip Data.Map.Internal.Tip)-                          )-                          inp-                          Data.Map.Internal.Tip-              name = \(!ok) (!inp) (!koByLabel) ->-                let _ = "catch ExceptionFailure"-                 in let catchHandler (!_exn) (!failInp) (!farInp) (!farExp) =-                          let _ = "catch.ko ExceptionFailure"-                           in if ( \( Data.Text.Internal.Text-                                        _-                                        i-                                        _-                                      )-                                    ( Data.Text.Internal.Text-                                        _-                                        j-                                        _-                                      ) -> i GHC.Classes.== j-                                 )-                                inp-                                failInp-                                then-                                  let _ = "choicesBranch.then"-                                   in let _ = "resume"-                                       in ok-                                            farInp-                                            farExp-                                            ( let _ = "resume.genCode"-                                               in \x -> x-                                            )-                                            failInp-                                else-                                  let _ = "choicesBranch.else"-                                   in Data.Map.Strict.Internal.findWithDefault finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure koByLabel Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp farInp farExp-                     in name-                          ( let _ = "suspend"-                             in \farInp farExp v (!inp) ->-                                  name-                                    ( let _ = "suspend"-                                       in \farInp farExp v (!inp) ->-                                            name-                                              ( let _ = "suspend"-                                                 in \farInp farExp v (!inp) ->-                                                      name-                                                        ( let _ = "suspend"-                                                           in \farInp farExp v (!inp) ->-                                                                let _ = "resume"-                                                                 in ok-                                                                      farInp-                                                                      farExp-                                                                      ( let _ = "resume.genCode"-                                                                         in \x -> v v (v x)-                                                                      )-                                                                      inp-                                                        )-                                                        inp-                                                        (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure catchHandler Data.Map.Internal.Tip Data.Map.Internal.Tip)-                                              )-                                              inp-                                              (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure catchHandler Data.Map.Internal.Tip Data.Map.Internal.Tip)-                                    )-                                    inp-                                    (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure catchHandler Data.Map.Internal.Tip Data.Map.Internal.Tip)-                          )-                          inp-                          Data.Map.Internal.Tip-              name = \(!ok) (!inp) (!koByLabel) ->-                let _ = "catch ExceptionFailure"-                 in let catchHandler (!_exn) (!failInp) (!farInp) (!farExp) =-                          let _ = "catch.ko ExceptionFailure"-                           in if ( \( Data.Text.Internal.Text-                                        _-                                        i-                                        _-                                      )-                                    ( Data.Text.Internal.Text-                                        _-                                        j-                                        _-                                      ) -> i GHC.Classes.== j-                                 )-                                inp-                                failInp-                                then-                                  let _ = "choicesBranch.then"-                                   in let _ = "resume"-                                       in ok-                                            farInp-                                            farExp-                                            ( let _ = "resume.genCode"-                                               in \x -> x-                                            )-                                            failInp-                                else-                                  let _ = "choicesBranch.else"-                                   in Data.Map.Strict.Internal.findWithDefault finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure koByLabel Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp farInp farExp-                     in name-                          ( let _ = "suspend"-                             in \farInp farExp v (!inp) ->-                                  name-                                    ( let _ = "suspend"-                                       in \farInp farExp v (!inp) ->-                                            let _ = "resume"-                                             in ok-                                                  farInp-                                                  farExp-                                                  ( let _ = "resume.genCode"-                                                     in \x -> v x-                                                  )-                                                  inp-                                    )-                                    inp-                                    (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure catchHandler Data.Map.Internal.Tip Data.Map.Internal.Tip)-                          )-                          inp-                          (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure catchHandler Data.Map.Internal.Tip Data.Map.Internal.Tip)-              name = \(!ok) (!inp) (!koByLabel) ->-                let _ = "catch ExceptionFailure"-                 in let catchHandler (!_exn) (!failInp) (!farInp) (!farExp) =-                          let _ = "catch.ko ExceptionFailure"-                           in if ( \( Data.Text.Internal.Text-                                        _-                                        i-                                        _-                                      )-                                    ( Data.Text.Internal.Text-                                        _-                                        j-                                        _-                                      ) -> i GHC.Classes.== j-                                 )-                                inp-                                failInp-                                then-                                  let _ = "choicesBranch.then"-                                   in let _ = "resume"-                                       in ok-                                            farInp-                                            farExp-                                            ( let _ = "resume.genCode"-                                               in \x -> x-                                            )-                                            failInp-                                else-                                  let _ = "choicesBranch.else"-                                   in Data.Map.Strict.Internal.findWithDefault finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure koByLabel Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp farInp farExp-                     in name-                          ( let _ = "suspend"-                             in \farInp farExp v (!inp) ->-                                  name-                                    ( let _ = "suspend"-                                       in \farInp farExp v (!inp) ->-                                            let _ = "resume"-                                             in ok-                                                  farInp-                                                  farExp-                                                  ( let _ = "resume.genCode"-                                                     in \x -> v x-                                                  )-                                                  inp-                                    )-                                    inp-                                    (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure catchHandler Data.Map.Internal.Tip Data.Map.Internal.Tip)-                          )-                          inp-                          (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure catchHandler Data.Map.Internal.Tip Data.Map.Internal.Tip)-              name = \(!ok) (!inp) (!koByLabel) ->-                let _ = "catch ExceptionFailure"-                 in let catchHandler (!_exn) (!failInp) (!farInp) (!farExp) =-                          let _ = "catch.ko ExceptionFailure"-                           in if ( \( Data.Text.Internal.Text-                                        _-                                        i-                                        _-                                      )-                                    ( Data.Text.Internal.Text-                                        _-                                        j-                                        _-                                      ) -> i GHC.Classes.== j-                                 )-                                inp-                                failInp-                                then-                                  let _ = "choicesBranch.then"-                                   in let _ = "resume"-                                       in ok-                                            farInp-                                            farExp-                                            ( let _ = "resume.genCode"-                                               in \x -> x-                                            )-                                            failInp-                                else-                                  let _ = "choicesBranch.else"-                                   in Data.Map.Strict.Internal.findWithDefault finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure koByLabel Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp farInp farExp-                     in let join = \farInp farExp v (!inp) ->-                              name-                                ( let _ = "suspend"-                                   in \farInp farExp v (!inp) ->-                                        let _ = "resume"-                                         in ok-                                              farInp-                                              farExp-                                              ( let _ = "resume.genCode"-                                                 in \x -> v x-                                              )-                                              inp-                                )-                                inp-                                (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure catchHandler Data.Map.Internal.Tip Data.Map.Internal.Tip)-                         in let _ = "catch ExceptionFailure"-                             in let catchHandler (!_exn) (!failInp) (!farInp) (!farExp) =-                                      let _ = "catch.ko ExceptionFailure"-                                       in if ( \( Data.Text.Internal.Text-                                                    _-                                                    i-                                                    _-                                                  )-                                                ( Data.Text.Internal.Text-                                                    _-                                                    j-                                                    _-                                                  ) -> i GHC.Classes.== j-                                             )-                                            inp-                                            failInp-                                            then-                                              let _ = "choicesBranch.then"-                                               in name-                                                    ( let _ = "suspend"-                                                       in \farInp farExp v (!inp) ->-                                                            name-                                                              ( let _ = "suspend"-                                                                 in \farInp farExp v (!inp) ->-                                                                      let _ = "resume"-                                                                       in join-                                                                            farInp-                                                                            farExp-                                                                            ( let _ = "resume.genCode"-                                                                               in v-                                                                            )-                                                                            inp-                                                              )-                                                              inp-                                                              (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure catchHandler Data.Map.Internal.Tip Data.Map.Internal.Tip)-                                                    )-                                                    failInp-                                                    (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure catchHandler Data.Map.Internal.Tip Data.Map.Internal.Tip)-                                            else-                                              let _ = "choicesBranch.else"-                                               in catchHandler Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp farInp farExp-                                 in let join = \farInp farExp v (!inp) ->-                                          let _ = "resume"-                                           in join-                                                farInp-                                                farExp-                                                ( let _ = "resume.genCode"-                                                   in v-                                                )-                                                inp-                                     in let _ = "catch ExceptionFailure"-                                         in let catchHandler (!_exn) (!failInp) (!farInp) (!farExp) =-                                                  let _ = "catch.ko ExceptionFailure"-                                                   in if ( \( Data.Text.Internal.Text-                                                                _-                                                                i-                                                                _-                                                              )-                                                            ( Data.Text.Internal.Text-                                                                _-                                                                j-                                                                _-                                                              ) -> i GHC.Classes.== j-                                                         )-                                                        inp-                                                        failInp-                                                        then-                                                          let _ = "choicesBranch.then"-                                                           in let _ = "catch ExceptionFailure"-                                                               in let catchHandler (!_exn) (!failInp) (!farInp) (!farExp) =-                                                                        let _ = "catch.ko ExceptionFailure"-                                                                         in catchHandler Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp farInp farExp-                                                                   in let join = \farInp farExp v (!inp) ->-                                                                            name-                                                                              ( let _ = "suspend"-                                                                                 in \farInp farExp v (!inp) ->-                                                                                      name-                                                                                        ( let _ = "suspend"-                                                                                           in \farInp farExp v (!inp) ->-                                                                                                name-                                                                                                  ( let _ = "suspend"-                                                                                                     in \farInp farExp v (!inp) ->-                                                                                                          name-                                                                                                            ( let _ = "suspend"-                                                                                                               in \farInp farExp v (!inp) ->-                                                                                                                    let readFail = catchHandler-                                                                                                                     in if readMore (Symantic.Parser.Machine.Input.shiftRightText 3 inp)-                                                                                                                          then-                                                                                                                            let !(#-                                                                                                                                   c,-                                                                                                                                   cs-                                                                                                                                   #) = readNext inp-                                                                                                                             in if (GHC.Classes.==) '=' c-                                                                                                                                  then-                                                                                                                                    name-                                                                                                                                      ( let _ = "suspend"-                                                                                                                                         in \farInp farExp v (!inp) ->-                                                                                                                                              name-                                                                                                                                                ( let _ = "suspend"-                                                                                                                                                   in \farInp farExp v (!inp) ->-                                                                                                                                                        name-                                                                                                                                                          ( let _ = "suspend"-                                                                                                                                                             in \farInp farExp v (!inp) ->-                                                                                                                                                                  name-                                                                                                                                                                    ( let _ = "suspend"-                                                                                                                                                                       in \farInp farExp v (!inp) ->-                                                                                                                                                                            name-                                                                                                                                                                              ( let _ = "suspend"-                                                                                                                                                                                 in \farInp farExp v (!inp) ->-                                                                                                                                                                                      name-                                                                                                                                                                                        ( let _ = "suspend"-                                                                                                                                                                                           in \farInp farExp v (!inp) ->-                                                                                                                                                                                                let _ = "resume"-                                                                                                                                                                                                 in join-                                                                                                                                                                                                      farInp-                                                                                                                                                                                                      farExp-                                                                                                                                                                                                      ( let _ = "resume.genCode"-                                                                                                                                                                                                         in v-                                                                                                                                                                                                      )-                                                                                                                                                                                                      inp-                                                                                                                                                                                        )-                                                                                                                                                                                        inp-                                                                                                                                                                                        (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure readFail Data.Map.Internal.Tip Data.Map.Internal.Tip)-                                                                                                                                                                              )-                                                                                                                                                                              inp-                                                                                                                                                                              Data.Map.Internal.Tip-                                                                                                                                                                    )-                                                                                                                                                                    inp-                                                                                                                                                                    (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure readFail Data.Map.Internal.Tip Data.Map.Internal.Tip)-                                                                                                                                                          )-                                                                                                                                                          inp-                                                                                                                                                          Data.Map.Internal.Tip-                                                                                                                                                )-                                                                                                                                                inp-                                                                                                                                                (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure readFail Data.Map.Internal.Tip Data.Map.Internal.Tip)-                                                                                                                                      )-                                                                                                                                      cs-                                                                                                                                      (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure readFail Data.Map.Internal.Tip Data.Map.Internal.Tip)-                                                                                                                                  else-                                                                                                                                    let _ = "checkToken.else"-                                                                                                                                     in let failExp =-                                                                                                                                              Data.Set.Internal.Bin-                                                                                                                                                1-                                                                                                                                                ( Symantic.Parser.Grammar.Combinators.SomeFailure-                                                                                                                                                    ( case inputToken of-                                                                                                                                                        (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken '='-                                                                                                                                                    )-                                                                                                                                                )-                                                                                                                                                Data.Set.Internal.Tip-                                                                                                                                                Data.Set.Internal.Tip-                                                                                                                                         in let (#-                                                                                                                                                  farInp,-                                                                                                                                                  farExp-                                                                                                                                                  #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp inp of-                                                                                                                                                    GHC.Types.LT ->-                                                                                                                                                      (#-                                                                                                                                                        inp,-                                                                                                                                                        failExp-                                                                                                                                                      #)-                                                                                                                                                    GHC.Types.EQ ->-                                                                                                                                                      (#-                                                                                                                                                        farInp,-                                                                                                                                                        failExp GHC.Base.<> farExp-                                                                                                                                                      #)-                                                                                                                                                    GHC.Types.GT ->-                                                                                                                                                      (#-                                                                                                                                                        farInp,-                                                                                                                                                        farExp-                                                                                                                                                      #)-                                                                                                                                             in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp-                                                                                                                          else-                                                                                                                            let _ = "checkHorizon.else"-                                                                                                                             in let failExp =-                                                                                                                                      Data.Set.Internal.Bin-                                                                                                                                        1-                                                                                                                                        ( Symantic.Parser.Grammar.Combinators.SomeFailure-                                                                                                                                            ( case inputToken of-                                                                                                                                                (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureHorizon @tok' 4-                                                                                                                                            )-                                                                                                                                        )-                                                                                                                                        Data.Set.Internal.Tip-                                                                                                                                        Data.Set.Internal.Tip-                                                                                                                                 in let (#-                                                                                                                                          farInp,-                                                                                                                                          farExp-                                                                                                                                          #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp inp of-                                                                                                                                            GHC.Types.LT ->-                                                                                                                                              (#-                                                                                                                                                inp,-                                                                                                                                                failExp-                                                                                                                                              #)-                                                                                                                                            GHC.Types.EQ ->-                                                                                                                                              (#-                                                                                                                                                farInp,-                                                                                                                                                failExp GHC.Base.<> farExp-                                                                                                                                              #)-                                                                                                                                            GHC.Types.GT ->-                                                                                                                                              (#-                                                                                                                                                farInp,-                                                                                                                                                farExp-                                                                                                                                              #)-                                                                                                                                     in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp-                                                                                                            )-                                                                                                            inp-                                                                                                            Data.Map.Internal.Tip-                                                                                                  )-                                                                                                  inp-                                                                                                  (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure catchHandler Data.Map.Internal.Tip Data.Map.Internal.Tip)-                                                                                        )-                                                                                        inp-                                                                                        Data.Map.Internal.Tip-                                                                              )-                                                                              inp-                                                                              (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure catchHandler Data.Map.Internal.Tip Data.Map.Internal.Tip)-                                                                       in let _ = "catch ExceptionFailure"-                                                                           in let catchHandler (!_exn) (!failInp) (!farInp) (!farExp) =-                                                                                    let _ = "catch.ko ExceptionFailure"-                                                                                     in if ( \( Data.Text.Internal.Text-                                                                                                  _-                                                                                                  i-                                                                                                  _-                                                                                                )-                                                                                              ( Data.Text.Internal.Text-                                                                                                  _-                                                                                                  j-                                                                                                  _-                                                                                                ) -> i GHC.Classes.== j-                                                                                           )-                                                                                          failInp-                                                                                          failInp-                                                                                          then-                                                                                            let _ = "choicesBranch.then"-                                                                                             in name-                                                                                                  ( let _ = "suspend"-                                                                                                     in \farInp farExp v (!inp) ->-                                                                                                          let _ = "resume"-                                                                                                           in join-                                                                                                                farInp-                                                                                                                farExp-                                                                                                                ( let _ = "resume.genCode"-                                                                                                                   in v-                                                                                                                )-                                                                                                                inp-                                                                                                  )-                                                                                                  failInp-                                                                                                  Data.Map.Internal.Tip-                                                                                          else-                                                                                            let _ = "choicesBranch.else"-                                                                                             in catchHandler Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp farInp farExp-                                                                               in let _ = "catch ExceptionFailure"-                                                                                   in let catchHandler (!_exn) (!failInp) (!farInp) (!farExp) =-                                                                                            let _ = "catch.ko ExceptionFailure"-                                                                                             in catchHandler Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp farInp farExp-                                                                                       in let readFail = catchHandler-                                                                                           in if readMore (Symantic.Parser.Machine.Input.shiftRightText 10 failInp)-                                                                                                then-                                                                                                  let !(#-                                                                                                         c,-                                                                                                         cs-                                                                                                         #) = readNext failInp-                                                                                                   in if (GHC.Classes.==) 'v' c-                                                                                                        then-                                                                                                          let readFail = readFail-                                                                                                           in let !(#-                                                                                                                     c,-                                                                                                                     cs-                                                                                                                     #) = readNext cs-                                                                                                               in if (GHC.Classes.==) 'a' c-                                                                                                                    then-                                                                                                                      let readFail = readFail-                                                                                                                       in let !(#-                                                                                                                                 c,-                                                                                                                                 cs-                                                                                                                                 #) = readNext cs-                                                                                                                           in if (GHC.Classes.==) 'r' c-                                                                                                                                then-                                                                                                                                  name-                                                                                                                                    ( let _ = "suspend"-                                                                                                                                       in \farInp farExp v (!inp) ->-                                                                                                                                            let _ = "resume"-                                                                                                                                             in join-                                                                                                                                                  farInp-                                                                                                                                                  farExp-                                                                                                                                                  ( let _ = "resume.genCode"-                                                                                                                                                     in GHC.Tuple . ()-                                                                                                                                                  )-                                                                                                                                                  inp-                                                                                                                                    )-                                                                                                                                    cs-                                                                                                                                    Data.Map.Internal.Tip-                                                                                                                                else-                                                                                                                                  let _ = "checkToken.else"-                                                                                                                                   in let failExp =-                                                                                                                                            Data.Set.Internal.Bin-                                                                                                                                              1-                                                                                                                                              ( Symantic.Parser.Grammar.Combinators.SomeFailure-                                                                                                                                                  ( case inputToken of-                                                                                                                                                      (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken 'r'-                                                                                                                                                  )-                                                                                                                                              )-                                                                                                                                              Data.Set.Internal.Tip-                                                                                                                                              Data.Set.Internal.Tip-                                                                                                                                       in let (#-                                                                                                                                                farInp,-                                                                                                                                                farExp-                                                                                                                                                #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp cs of-                                                                                                                                                  GHC.Types.LT ->-                                                                                                                                                    (#-                                                                                                                                                      cs,-                                                                                                                                                      failExp-                                                                                                                                                    #)-                                                                                                                                                  GHC.Types.EQ ->-                                                                                                                                                    (#-                                                                                                                                                      farInp,-                                                                                                                                                      failExp GHC.Base.<> farExp-                                                                                                                                                    #)-                                                                                                                                                  GHC.Types.GT ->-                                                                                                                                                    (#-                                                                                                                                                      farInp,-                                                                                                                                                      farExp-                                                                                                                                                    #)-                                                                                                                                           in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure cs farInp farExp-                                                                                                                    else-                                                                                                                      let _ = "checkToken.else"-                                                                                                                       in let failExp =-                                                                                                                                Data.Set.Internal.Bin-                                                                                                                                  1-                                                                                                                                  ( Symantic.Parser.Grammar.Combinators.SomeFailure-                                                                                                                                      ( case inputToken of-                                                                                                                                          (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken 'a'-                                                                                                                                      )-                                                                                                                                  )-                                                                                                                                  Data.Set.Internal.Tip-                                                                                                                                  Data.Set.Internal.Tip-                                                                                                                           in let (#-                                                                                                                                    farInp,-                                                                                                                                    farExp-                                                                                                                                    #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp cs of-                                                                                                                                      GHC.Types.LT ->-                                                                                                                                        (#-                                                                                                                                          cs,-                                                                                                                                          failExp-                                                                                                                                        #)-                                                                                                                                      GHC.Types.EQ ->-                                                                                                                                        (#-                                                                                                                                          farInp,-                                                                                                                                          failExp GHC.Base.<> farExp-                                                                                                                                        #)-                                                                                                                                      GHC.Types.GT ->-                                                                                                                                        (#-                                                                                                                                          farInp,-                                                                                                                                          farExp-                                                                                                                                        #)-                                                                                                                               in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure cs farInp farExp-                                                                                                        else-                                                                                                          let _ = "checkToken.else"-                                                                                                           in let failExp =-                                                                                                                    Data.Set.Internal.Bin-                                                                                                                      1-                                                                                                                      ( Symantic.Parser.Grammar.Combinators.SomeFailure-                                                                                                                          ( case inputToken of-                                                                                                                              (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken 'v'-                                                                                                                          )-                                                                                                                      )-                                                                                                                      Data.Set.Internal.Tip-                                                                                                                      Data.Set.Internal.Tip-                                                                                                               in let (#-                                                                                                                        farInp,-                                                                                                                        farExp-                                                                                                                        #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp failInp of-                                                                                                                          GHC.Types.LT ->-                                                                                                                            (#-                                                                                                                              failInp,-                                                                                                                              failExp-                                                                                                                            #)-                                                                                                                          GHC.Types.EQ ->-                                                                                                                            (#-                                                                                                                              farInp,-                                                                                                                              failExp GHC.Base.<> farExp-                                                                                                                            #)-                                                                                                                          GHC.Types.GT ->-                                                                                                                            (#-                                                                                                                              farInp,-                                                                                                                              farExp-                                                                                                                            #)-                                                                                                                   in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp farInp farExp-                                                                                                else-                                                                                                  let _ = "checkHorizon.else"-                                                                                                   in let failExp =-                                                                                                            Data.Set.Internal.Bin-                                                                                                              1-                                                                                                              ( Symantic.Parser.Grammar.Combinators.SomeFailure-                                                                                                                  ( case inputToken of-                                                                                                                      (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureHorizon @tok' 11-                                                                                                                  )-                                                                                                              )-                                                                                                              Data.Set.Internal.Tip-                                                                                                              Data.Set.Internal.Tip-                                                                                                       in let (#-                                                                                                                farInp,-                                                                                                                farExp-                                                                                                                #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp failInp of-                                                                                                                  GHC.Types.LT ->-                                                                                                                    (#-                                                                                                                      failInp,-                                                                                                                      failExp-                                                                                                                    #)-                                                                                                                  GHC.Types.EQ ->-                                                                                                                    (#-                                                                                                                      farInp,-                                                                                                                      failExp GHC.Base.<> farExp-                                                                                                                    #)-                                                                                                                  GHC.Types.GT ->-                                                                                                                    (#-                                                                                                                      farInp,-                                                                                                                      farExp-                                                                                                                    #)-                                                                                                           in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp farInp farExp-                                                        else-                                                          let _ = "choicesBranch.else"-                                                           in catchHandler Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp farInp farExp-                                             in let join = \farInp farExp v (!inp) ->-                                                      let _ = "resume"-                                                       in join-                                                            farInp-                                                            farExp-                                                            ( let _ = "resume.genCode"-                                                               in v-                                                            )-                                                            inp-                                                 in let _ = "catch ExceptionFailure"-                                                     in let catchHandler (!_exn) (!failInp) (!farInp) (!farExp) =-                                                              let _ = "catch.ko ExceptionFailure"-                                                               in if ( \( Data.Text.Internal.Text-                                                                            _-                                                                            i-                                                                            _-                                                                          )-                                                                        ( Data.Text.Internal.Text-                                                                            _-                                                                            j-                                                                            _-                                                                          ) -> i GHC.Classes.== j-                                                                     )-                                                                    inp-                                                                    failInp-                                                                    then-                                                                      let _ = "choicesBranch.then"-                                                                       in let _ = "catch ExceptionFailure"-                                                                           in let catchHandler (!_exn) (!failInp) (!farInp) (!farExp) =-                                                                                    let _ = "catch.ko ExceptionFailure"-                                                                                     in catchHandler Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp farInp farExp-                                                                               in let readFail = catchHandler-                                                                                   in if readMore (Symantic.Parser.Machine.Input.shiftRightText 10 failInp)-                                                                                        then-                                                                                          let !(#-                                                                                                 c,-                                                                                                 cs-                                                                                                 #) = readNext failInp-                                                                                           in if (GHC.Classes.==) 'w' c-                                                                                                then-                                                                                                  let readFail = readFail-                                                                                                   in let !(#-                                                                                                             c,-                                                                                                             cs-                                                                                                             #) = readNext cs-                                                                                                       in if (GHC.Classes.==) 'h' c-                                                                                                            then-                                                                                                              let readFail = readFail-                                                                                                               in let !(#-                                                                                                                         c,-                                                                                                                         cs-                                                                                                                         #) = readNext cs-                                                                                                                   in if (GHC.Classes.==) 'i' c-                                                                                                                        then-                                                                                                                          let readFail = readFail-                                                                                                                           in let !(#-                                                                                                                                     c,-                                                                                                                                     cs-                                                                                                                                     #) = readNext cs-                                                                                                                               in if (GHC.Classes.==) 'l' c-                                                                                                                                    then-                                                                                                                                      let readFail = readFail-                                                                                                                                       in let !(#-                                                                                                                                                 c,-                                                                                                                                                 cs-                                                                                                                                                 #) = readNext cs-                                                                                                                                           in if (GHC.Classes.==) 'e' c-                                                                                                                                                then-                                                                                                                                                  name-                                                                                                                                                    ( let _ = "suspend"-                                                                                                                                                       in \farInp farExp v (!inp) ->-                                                                                                                                                            name-                                                                                                                                                              ( let _ = "suspend"-                                                                                                                                                                 in \farInp farExp v (!inp) ->-                                                                                                                                                                      name-                                                                                                                                                                        ( let _ = "suspend"-                                                                                                                                                                           in \farInp farExp v (!inp) ->-                                                                                                                                                                                let _ = "resume"-                                                                                                                                                                                 in join-                                                                                                                                                                                      farInp-                                                                                                                                                                                      farExp-                                                                                                                                                                                      ( let _ = "resume.genCode"-                                                                                                                                                                                         in v-                                                                                                                                                                                      )-                                                                                                                                                                                      inp-                                                                                                                                                                        )-                                                                                                                                                                        inp-                                                                                                                                                                        (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure catchHandler Data.Map.Internal.Tip Data.Map.Internal.Tip)-                                                                                                                                                              )-                                                                                                                                                              inp-                                                                                                                                                              (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure catchHandler Data.Map.Internal.Tip Data.Map.Internal.Tip)-                                                                                                                                                    )-                                                                                                                                                    cs-                                                                                                                                                    Data.Map.Internal.Tip-                                                                                                                                                else-                                                                                                                                                  let _ = "checkToken.else"-                                                                                                                                                   in let failExp =-                                                                                                                                                            Data.Set.Internal.Bin-                                                                                                                                                              1-                                                                                                                                                              ( Symantic.Parser.Grammar.Combinators.SomeFailure-                                                                                                                                                                  ( case inputToken of-                                                                                                                                                                      (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken 'e'-                                                                                                                                                                  )-                                                                                                                                                              )-                                                                                                                                                              Data.Set.Internal.Tip-                                                                                                                                                              Data.Set.Internal.Tip-                                                                                                                                                       in let (#-                                                                                                                                                                farInp,-                                                                                                                                                                farExp-                                                                                                                                                                #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp cs of-                                                                                                                                                                  GHC.Types.LT ->-                                                                                                                                                                    (#-                                                                                                                                                                      cs,-                                                                                                                                                                      failExp-                                                                                                                                                                    #)-                                                                                                                                                                  GHC.Types.EQ ->-                                                                                                                                                                    (#-                                                                                                                                                                      farInp,-                                                                                                                                                                      failExp GHC.Base.<> farExp-                                                                                                                                                                    #)-                                                                                                                                                                  GHC.Types.GT ->-                                                                                                                                                                    (#-                                                                                                                                                                      farInp,-                                                                                                                                                                      farExp-                                                                                                                                                                    #)-                                                                                                                                                           in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure cs farInp farExp-                                                                                                                                    else-                                                                                                                                      let _ = "checkToken.else"-                                                                                                                                       in let failExp =-                                                                                                                                                Data.Set.Internal.Bin-                                                                                                                                                  1-                                                                                                                                                  ( Symantic.Parser.Grammar.Combinators.SomeFailure-                                                                                                                                                      ( case inputToken of-                                                                                                                                                          (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken 'l'-                                                                                                                                                      )-                                                                                                                                                  )-                                                                                                                                                  Data.Set.Internal.Tip-                                                                                                                                                  Data.Set.Internal.Tip-                                                                                                                                           in let (#-                                                                                                                                                    farInp,-                                                                                                                                                    farExp-                                                                                                                                                    #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp cs of-                                                                                                                                                      GHC.Types.LT ->-                                                                                                                                                        (#-                                                                                                                                                          cs,-                                                                                                                                                          failExp-                                                                                                                                                        #)-                                                                                                                                                      GHC.Types.EQ ->-                                                                                                                                                        (#-                                                                                                                                                          farInp,-                                                                                                                                                          failExp GHC.Base.<> farExp-                                                                                                                                                        #)-                                                                                                                                                      GHC.Types.GT ->-                                                                                                                                                        (#-                                                                                                                                                          farInp,-                                                                                                                                                          farExp-                                                                                                                                                        #)-                                                                                                                                               in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure cs farInp farExp-                                                                                                                        else-                                                                                                                          let _ = "checkToken.else"-                                                                                                                           in let failExp =-                                                                                                                                    Data.Set.Internal.Bin-                                                                                                                                      1-                                                                                                                                      ( Symantic.Parser.Grammar.Combinators.SomeFailure-                                                                                                                                          ( case inputToken of-                                                                                                                                              (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken 'i'-                                                                                                                                          )-                                                                                                                                      )-                                                                                                                                      Data.Set.Internal.Tip-                                                                                                                                      Data.Set.Internal.Tip-                                                                                                                               in let (#-                                                                                                                                        farInp,-                                                                                                                                        farExp-                                                                                                                                        #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp cs of-                                                                                                                                          GHC.Types.LT ->-                                                                                                                                            (#-                                                                                                                                              cs,-                                                                                                                                              failExp-                                                                                                                                            #)-                                                                                                                                          GHC.Types.EQ ->-                                                                                                                                            (#-                                                                                                                                              farInp,-                                                                                                                                              failExp GHC.Base.<> farExp-                                                                                                                                            #)-                                                                                                                                          GHC.Types.GT ->-                                                                                                                                            (#-                                                                                                                                              farInp,-                                                                                                                                              farExp-                                                                                                                                            #)-                                                                                                                                   in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure cs farInp farExp-                                                                                                            else-                                                                                                              let _ = "checkToken.else"-                                                                                                               in let failExp =-                                                                                                                        Data.Set.Internal.Bin-                                                                                                                          1-                                                                                                                          ( Symantic.Parser.Grammar.Combinators.SomeFailure-                                                                                                                              ( case inputToken of-                                                                                                                                  (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken 'h'-                                                                                                                              )-                                                                                                                          )-                                                                                                                          Data.Set.Internal.Tip-                                                                                                                          Data.Set.Internal.Tip-                                                                                                                   in let (#-                                                                                                                            farInp,-                                                                                                                            farExp-                                                                                                                            #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp cs of-                                                                                                                              GHC.Types.LT ->-                                                                                                                                (#-                                                                                                                                  cs,-                                                                                                                                  failExp-                                                                                                                                #)-                                                                                                                              GHC.Types.EQ ->-                                                                                                                                (#-                                                                                                                                  farInp,-                                                                                                                                  failExp GHC.Base.<> farExp-                                                                                                                                #)-                                                                                                                              GHC.Types.GT ->-                                                                                                                                (#-                                                                                                                                  farInp,-                                                                                                                                  farExp-                                                                                                                                #)-                                                                                                                       in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure cs farInp farExp-                                                                                                else-                                                                                                  let _ = "checkToken.else"-                                                                                                   in let failExp =-                                                                                                            Data.Set.Internal.Bin-                                                                                                              1-                                                                                                              ( Symantic.Parser.Grammar.Combinators.SomeFailure-                                                                                                                  ( case inputToken of-                                                                                                                      (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken 'w'-                                                                                                                  )-                                                                                                              )-                                                                                                              Data.Set.Internal.Tip-                                                                                                              Data.Set.Internal.Tip-                                                                                                       in let (#-                                                                                                                farInp,-                                                                                                                farExp-                                                                                                                #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp failInp of-                                                                                                                  GHC.Types.LT ->-                                                                                                                    (#-                                                                                                                      failInp,-                                                                                                                      failExp-                                                                                                                    #)-                                                                                                                  GHC.Types.EQ ->-                                                                                                                    (#-                                                                                                                      farInp,-                                                                                                                      failExp GHC.Base.<> farExp-                                                                                                                    #)-                                                                                                                  GHC.Types.GT ->-                                                                                                                    (#-                                                                                                                      farInp,-                                                                                                                      farExp-                                                                                                                    #)-                                                                                                           in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp farInp farExp-                                                                                        else-                                                                                          let _ = "checkHorizon.else"-                                                                                           in let failExp =-                                                                                                    Data.Set.Internal.Bin-                                                                                                      1-                                                                                                      ( Symantic.Parser.Grammar.Combinators.SomeFailure-                                                                                                          ( case inputToken of-                                                                                                              (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureHorizon @tok' 11-                                                                                                          )-                                                                                                      )-                                                                                                      Data.Set.Internal.Tip-                                                                                                      Data.Set.Internal.Tip-                                                                                               in let (#-                                                                                                        farInp,-                                                                                                        farExp-                                                                                                        #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp failInp of-                                                                                                          GHC.Types.LT ->-                                                                                                            (#-                                                                                                              failInp,-                                                                                                              failExp-                                                                                                            #)-                                                                                                          GHC.Types.EQ ->-                                                                                                            (#-                                                                                                              farInp,-                                                                                                              failExp GHC.Base.<> farExp-                                                                                                            #)-                                                                                                          GHC.Types.GT ->-                                                                                                            (#-                                                                                                              farInp,-                                                                                                              farExp-                                                                                                            #)-                                                                                                   in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp farInp farExp-                                                                    else-                                                                      let _ = "choicesBranch.else"-                                                                       in catchHandler Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp farInp farExp-                                                         in let _ = "catch ExceptionFailure"-                                                             in let catchHandler (!_exn) (!failInp) (!farInp) (!farExp) =-                                                                      let _ = "catch.ko ExceptionFailure"-                                                                       in catchHandler Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp-                                                                 in let readFail = catchHandler-                                                                     in if readMore (Symantic.Parser.Machine.Input.shiftRightText 1 inp)-                                                                          then-                                                                            let !(#-                                                                                   c,-                                                                                   cs-                                                                                   #) = readNext inp-                                                                             in if (GHC.Classes.==) 'i' c-                                                                                  then-                                                                                    let readFail = readFail-                                                                                     in let !(#-                                                                                               c,-                                                                                               cs-                                                                                               #) = readNext cs-                                                                                         in if (GHC.Classes.==) 'f' c-                                                                                              then-                                                                                                name-                                                                                                  ( let _ = "suspend"-                                                                                                     in \farInp farExp v (!inp) ->-                                                                                                          let _ = "resume"-                                                                                                           in join-                                                                                                                farInp-                                                                                                                farExp-                                                                                                                ( let _ = "resume.genCode"-                                                                                                                   in v-                                                                                                                )-                                                                                                                inp-                                                                                                  )-                                                                                                  cs-                                                                                                  Data.Map.Internal.Tip-                                                                                              else-                                                                                                let _ = "checkToken.else"-                                                                                                 in let failExp =-                                                                                                          Data.Set.Internal.Bin-                                                                                                            1-                                                                                                            ( Symantic.Parser.Grammar.Combinators.SomeFailure-                                                                                                                ( case inputToken of-                                                                                                                    (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken 'f'-                                                                                                                )-                                                                                                            )-                                                                                                            Data.Set.Internal.Tip-                                                                                                            Data.Set.Internal.Tip-                                                                                                     in let (#-                                                                                                              farInp,-                                                                                                              farExp-                                                                                                              #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init cs of-                                                                                                                GHC.Types.LT ->-                                                                                                                  (#-                                                                                                                    cs,-                                                                                                                    failExp-                                                                                                                  #)-                                                                                                                GHC.Types.EQ ->-                                                                                                                  (#-                                                                                                                    init,-                                                                                                                    failExp GHC.Base.<> Data.Set.Internal.empty-                                                                                                                  #)-                                                                                                                GHC.Types.GT ->-                                                                                                                  (#-                                                                                                                    init,-                                                                                                                    Data.Set.Internal.empty-                                                                                                                  #)-                                                                                                         in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure cs farInp farExp-                                                                                  else-                                                                                    let _ = "checkToken.else"-                                                                                     in let failExp =-                                                                                              Data.Set.Internal.Bin-                                                                                                1-                                                                                                ( Symantic.Parser.Grammar.Combinators.SomeFailure-                                                                                                    ( case inputToken of-                                                                                                        (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken 'i'-                                                                                                    )-                                                                                                )-                                                                                                Data.Set.Internal.Tip-                                                                                                Data.Set.Internal.Tip-                                                                                         in let (#-                                                                                                  farInp,-                                                                                                  farExp-                                                                                                  #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init inp of-                                                                                                    GHC.Types.LT ->-                                                                                                      (#-                                                                                                        inp,-                                                                                                        failExp-                                                                                                      #)-                                                                                                    GHC.Types.EQ ->-                                                                                                      (#-                                                                                                        init,-                                                                                                        failExp GHC.Base.<> Data.Set.Internal.empty-                                                                                                      #)-                                                                                                    GHC.Types.GT ->-                                                                                                      (#-                                                                                                        init,-                                                                                                        Data.Set.Internal.empty-                                                                                                      #)-                                                                                             in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp-                                                                          else-                                                                            let _ = "checkHorizon.else"-                                                                             in let failExp =-                                                                                      Data.Set.Internal.Bin-                                                                                        1-                                                                                        ( Symantic.Parser.Grammar.Combinators.SomeFailure-                                                                                            ( case inputToken of-                                                                                                (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureHorizon @tok' 2-                                                                                            )-                                                                                        )-                                                                                        Data.Set.Internal.Tip-                                                                                        Data.Set.Internal.Tip-                                                                                 in let (#-                                                                                          farInp,-                                                                                          farExp-                                                                                          #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init inp of-                                                                                            GHC.Types.LT ->-                                                                                              (#-                                                                                                inp,-                                                                                                failExp-                                                                                              #)-                                                                                            GHC.Types.EQ ->-                                                                                              (#-                                                                                                init,-                                                                                                failExp GHC.Base.<> Data.Set.Internal.empty-                                                                                              #)-                                                                                            GHC.Types.GT ->-                                                                                              (#-                                                                                                init,-                                                                                                Data.Set.Internal.empty-                                                                                              #)-                                                                                     in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp-              name = \(!ok) (!inp) (!koByLabel) ->-                let _ = "catch ExceptionFailure"-                 in let catchHandler (!_exn) (!failInp) (!farInp) (!farExp) =-                          let _ = "catch.ko ExceptionFailure"-                           in if ( \( Data.Text.Internal.Text-                                        _-                                        i-                                        _-                                      )-                                    ( Data.Text.Internal.Text-                                        _-                                        j-                                        _-                                      ) -> i GHC.Classes.== j-                                 )-                                inp-                                failInp-                                then-                                  let _ = "choicesBranch.then"-                                   in let _ = "resume"-                                       in ok-                                            farInp-                                            farExp-                                            ( let _ = "resume.genCode"-                                               in \x -> x-                                            )-                                            failInp-                                else-                                  let _ = "choicesBranch.else"-                                   in Data.Map.Strict.Internal.findWithDefault finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure koByLabel Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp farInp farExp-                     in let readFail = catchHandler-                         in if readMore inp-                              then-                                let !(#-                                       c,-                                       cs-                                       #) = readNext inp-                                 in if Parsers.Nandlang.nandIdentLetter c-                                      then-                                        name-                                          ( let _ = "suspend"-                                             in \farInp farExp v (!inp) ->-                                                  let _ = "resume"-                                                   in ok-                                                        farInp-                                                        farExp-                                                        ( let _ = "resume.genCode"-                                                           in \x -> v x-                                                        )-                                                        inp-                                          )-                                          cs-                                          (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure readFail Data.Map.Internal.Tip Data.Map.Internal.Tip)-                                      else-                                        let _ = "checkToken.else"-                                         in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure inp init Data.Set.Internal.empty-                              else-                                let _ = "checkHorizon.else"-                                 in let failExp =-                                          Data.Set.Internal.Bin-                                            1-                                            ( Symantic.Parser.Grammar.Combinators.SomeFailure-                                                ( case inputToken of-                                                    (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureHorizon @tok' 1-                                                )-                                            )-                                            Data.Set.Internal.Tip-                                            Data.Set.Internal.Tip-                                     in let (#-                                              farInp,-                                              farExp-                                              #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init inp of-                                                GHC.Types.LT ->-                                                  (#-                                                    inp,-                                                    failExp-                                                  #)-                                                GHC.Types.EQ ->-                                                  (#-                                                    init,-                                                    failExp GHC.Base.<> Data.Set.Internal.empty-                                                  #)-                                                GHC.Types.GT ->-                                                  (#-                                                    init,-                                                    Data.Set.Internal.empty-                                                  #)-                                         in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp-              name = \(!ok) (!inp) (!koByLabel) ->-                let _ = "catch ExceptionFailure"-                 in let catchHandler (!_exn) (!failInp) (!farInp) (!farExp) =-                          let _ = "catch.ko ExceptionFailure"-                           in if ( \( Data.Text.Internal.Text-                                        _-                                        i-                                        _-                                      )-                                    ( Data.Text.Internal.Text-                                        _-                                        j-                                        _-                                      ) -> i GHC.Classes.== j-                                 )-                                inp-                                failInp-                                then-                                  let _ = "choicesBranch.then"-                                   in let _ = "resume"-                                       in ok-                                            farInp-                                            farExp-                                            ( let _ = "resume.genCode"-                                               in \x -> x-                                            )-                                            failInp-                                else-                                  let _ = "choicesBranch.else"-                                   in Data.Map.Strict.Internal.findWithDefault finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure koByLabel Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp farInp farExp-                     in let readFail = catchHandler-                         in if readMore (Symantic.Parser.Machine.Input.shiftRightText 3 inp)-                              then-                                let !(#-                                       c,-                                       cs-                                       #) = readNext inp-                                 in if (GHC.Classes.==) '!' c-                                      then-                                        name-                                          ( let _ = "suspend"-                                             in \farInp farExp v (!inp) ->-                                                  name-                                                    ( let _ = "suspend"-                                                       in \farInp farExp v (!inp) ->-                                                            name-                                                              ( let _ = "suspend"-                                                                 in \farInp farExp v (!inp) ->-                                                                      let _ = "resume"-                                                                       in ok-                                                                            farInp-                                                                            farExp-                                                                            ( let _ = "resume.genCode"-                                                                               in \x -> v x-                                                                            )-                                                                            inp-                                                              )-                                                              inp-                                                              (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure readFail Data.Map.Internal.Tip Data.Map.Internal.Tip)-                                                    )-                                                    inp-                                                    (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure readFail Data.Map.Internal.Tip Data.Map.Internal.Tip)-                                          )-                                          cs-                                          (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure readFail Data.Map.Internal.Tip Data.Map.Internal.Tip)-                                      else-                                        let _ = "checkToken.else"-                                         in let failExp =-                                                  Data.Set.Internal.Bin-                                                    1-                                                    ( Symantic.Parser.Grammar.Combinators.SomeFailure-                                                        ( case inputToken of-                                                            (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken '!'-                                                        )-                                                    )-                                                    Data.Set.Internal.Tip-                                                    Data.Set.Internal.Tip-                                             in let (#-                                                      farInp,-                                                      farExp-                                                      #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init inp of-                                                        GHC.Types.LT ->-                                                          (#-                                                            inp,-                                                            failExp-                                                          #)-                                                        GHC.Types.EQ ->-                                                          (#-                                                            init,-                                                            failExp GHC.Base.<> Data.Set.Internal.empty-                                                          #)-                                                        GHC.Types.GT ->-                                                          (#-                                                            init,-                                                            Data.Set.Internal.empty-                                                          #)-                                                 in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp-                              else-                                let _ = "checkHorizon.else"-                                 in let failExp =-                                          Data.Set.Internal.Bin-                                            1-                                            ( Symantic.Parser.Grammar.Combinators.SomeFailure-                                                ( case inputToken of-                                                    (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureHorizon @tok' 4-                                                )-                                            )-                                            Data.Set.Internal.Tip-                                            Data.Set.Internal.Tip-                                     in let (#-                                              farInp,-                                              farExp-                                              #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init inp of-                                                GHC.Types.LT ->-                                                  (#-                                                    inp,-                                                    failExp-                                                  #)-                                                GHC.Types.EQ ->-                                                  (#-                                                    init,-                                                    failExp GHC.Base.<> Data.Set.Internal.empty-                                                  #)-                                                GHC.Types.GT ->-                                                  (#-                                                    init,-                                                    Data.Set.Internal.empty-                                                  #)-                                         in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp-              name = \(!ok) (!inp) (!koByLabel) ->-                let _ = "catch ExceptionFailure"-                 in let catchHandler (!_exn) (!failInp) (!farInp) (!farExp) =-                          let _ = "catch.ko ExceptionFailure"-                           in if ( \( Data.Text.Internal.Text-                                        _-                                        i-                                        _-                                      )-                                    ( Data.Text.Internal.Text-                                        _-                                        j-                                        _-                                      ) -> i GHC.Classes.== j-                                 )-                                inp-                                failInp-                                then-                                  let _ = "choicesBranch.then"-                                   in let _ = "resume"-                                       in ok-                                            farInp-                                            farExp-                                            ( let _ = "resume.genCode"-                                               in \x -> x-                                            )-                                            failInp-                                else-                                  let _ = "choicesBranch.else"-                                   in Data.Map.Strict.Internal.findWithDefault finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure koByLabel Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp farInp farExp-                     in let _ = "catch ExceptionFailure"-                         in let catchHandler (!_exn) (!failInp) (!farInp) (!farExp) =-                                  let _ = "catch.ko ExceptionFailure"-                                   in catchHandler Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp-                             in let readFail = catchHandler-                                 in if readMore (Symantic.Parser.Machine.Input.shiftRightText 17 inp)-                                      then-                                        let !(#-                                               c,-                                               cs-                                               #) = readNext inp-                                         in if (GHC.Classes.==) 'f' c-                                              then-                                                let readFail = readFail-                                                 in let !(#-                                                           c,-                                                           cs-                                                           #) = readNext cs-                                                     in if (GHC.Classes.==) 'u' c-                                                          then-                                                            let readFail = readFail-                                                             in let !(#-                                                                       c,-                                                                       cs-                                                                       #) = readNext cs-                                                                 in if (GHC.Classes.==) 'n' c-                                                                      then-                                                                        let readFail = readFail-                                                                         in let !(#-                                                                                   c,-                                                                                   cs-                                                                                   #) = readNext cs-                                                                             in if (GHC.Classes.==) 'c' c-                                                                                  then-                                                                                    let readFail = readFail-                                                                                     in let !(#-                                                                                               c,-                                                                                               cs-                                                                                               #) = readNext cs-                                                                                         in if (GHC.Classes.==) 't' c-                                                                                              then-                                                                                                let readFail = readFail-                                                                                                 in let !(#-                                                                                                           c,-                                                                                                           cs-                                                                                                           #) = readNext cs-                                                                                                     in if (GHC.Classes.==) 'i' c-                                                                                                          then-                                                                                                            let readFail = readFail-                                                                                                             in let !(#-                                                                                                                       c,-                                                                                                                       cs-                                                                                                                       #) = readNext cs-                                                                                                                 in if (GHC.Classes.==) 'o' c-                                                                                                                      then-                                                                                                                        let readFail = readFail-                                                                                                                         in let !(#-                                                                                                                                   c,-                                                                                                                                   cs-                                                                                                                                   #) = readNext cs-                                                                                                                             in if (GHC.Classes.==) 'n' c-                                                                                                                                  then-                                                                                                                                    name-                                                                                                                                      ( let _ = "suspend"-                                                                                                                                         in \farInp farExp v (!inp) ->-                                                                                                                                              name-                                                                                                                                                ( let _ = "suspend"-                                                                                                                                                   in \farInp farExp v (!inp) ->-                                                                                                                                                        name-                                                                                                                                                          ( let _ = "suspend"-                                                                                                                                                             in \farInp farExp v (!inp) ->-                                                                                                                                                                  name-                                                                                                                                                                    ( let _ = "suspend"-                                                                                                                                                                       in \farInp farExp v (!inp) ->-                                                                                                                                                                            let join = \farInp farExp v (!inp) ->-                                                                                                                                                                                  name-                                                                                                                                                                                    ( let _ = "suspend"-                                                                                                                                                                                       in \farInp farExp v (!inp) ->-                                                                                                                                                                                            name-                                                                                                                                                                                              ( let _ = "suspend"-                                                                                                                                                                                                 in \farInp farExp v (!inp) ->-                                                                                                                                                                                                      name-                                                                                                                                                                                                        ( let _ = "suspend"-                                                                                                                                                                                                           in \farInp farExp v (!inp) ->-                                                                                                                                                                                                                let _ = "resume"-                                                                                                                                                                                                                 in ok-                                                                                                                                                                                                                      farInp-                                                                                                                                                                                                                      farExp-                                                                                                                                                                                                                      ( let _ = "resume.genCode"-                                                                                                                                                                                                                         in \x -> v x-                                                                                                                                                                                                                      )-                                                                                                                                                                                                                      inp-                                                                                                                                                                                                        )-                                                                                                                                                                                                        inp-                                                                                                                                                                                                        (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure catchHandler Data.Map.Internal.Tip Data.Map.Internal.Tip)-                                                                                                                                                                                              )-                                                                                                                                                                                              inp-                                                                                                                                                                                              (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure catchHandler Data.Map.Internal.Tip Data.Map.Internal.Tip)-                                                                                                                                                                                    )-                                                                                                                                                                                    inp-                                                                                                                                                                                    (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure catchHandler Data.Map.Internal.Tip Data.Map.Internal.Tip)-                                                                                                                                                                             in let _ = "catch ExceptionFailure"-                                                                                                                                                                                 in let catchHandler (!_exn) (!failInp) (!farInp) (!farExp) =-                                                                                                                                                                                          let _ = "catch.ko ExceptionFailure"-                                                                                                                                                                                           in if ( \( Data.Text.Internal.Text-                                                                                                                                                                                                        _-                                                                                                                                                                                                        i-                                                                                                                                                                                                        _-                                                                                                                                                                                                      )-                                                                                                                                                                                                    ( Data.Text.Internal.Text-                                                                                                                                                                                                        _-                                                                                                                                                                                                        j-                                                                                                                                                                                                        _-                                                                                                                                                                                                      ) -> i GHC.Classes.== j-                                                                                                                                                                                                 )-                                                                                                                                                                                                inp-                                                                                                                                                                                                failInp-                                                                                                                                                                                                then-                                                                                                                                                                                                  let _ = "choicesBranch.then"-                                                                                                                                                                                                   in name-                                                                                                                                                                                                        ( let _ = "suspend"-                                                                                                                                                                                                           in \farInp farExp v (!inp) ->-                                                                                                                                                                                                                let _ = "resume"-                                                                                                                                                                                                                 in join-                                                                                                                                                                                                                      farInp-                                                                                                                                                                                                                      farExp-                                                                                                                                                                                                                      ( let _ = "resume.genCode"-                                                                                                                                                                                                                         in v-                                                                                                                                                                                                                      )-                                                                                                                                                                                                                      inp-                                                                                                                                                                                                        )-                                                                                                                                                                                                        failInp-                                                                                                                                                                                                        Data.Map.Internal.Tip-                                                                                                                                                                                                else-                                                                                                                                                                                                  let _ = "choicesBranch.else"-                                                                                                                                                                                                   in catchHandler Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp farInp farExp-                                                                                                                                                                                     in let readFail = catchHandler-                                                                                                                                                                                         in if readMore (Symantic.Parser.Machine.Input.shiftRightText 1 inp)-                                                                                                                                                                                              then-                                                                                                                                                                                                let !(#-                                                                                                                                                                                                       c,-                                                                                                                                                                                                       cs-                                                                                                                                                                                                       #) = readNext inp-                                                                                                                                                                                                 in if (GHC.Classes.==) ':' c-                                                                                                                                                                                                      then-                                                                                                                                                                                                        name-                                                                                                                                                                                                          ( let _ = "suspend"-                                                                                                                                                                                                             in \farInp farExp v (!inp) ->-                                                                                                                                                                                                                  name-                                                                                                                                                                                                                    ( let _ = "suspend"-                                                                                                                                                                                                                       in \farInp farExp v (!inp) ->-                                                                                                                                                                                                                            let _ = "resume"-                                                                                                                                                                                                                             in join-                                                                                                                                                                                                                                  farInp-                                                                                                                                                                                                                                  farExp-                                                                                                                                                                                                                                  ( let _ = "resume.genCode"-                                                                                                                                                                                                                                     in GHC.Tuple . ()-                                                                                                                                                                                                                                  )-                                                                                                                                                                                                                                  inp-                                                                                                                                                                                                                    )-                                                                                                                                                                                                                    inp-                                                                                                                                                                                                                    (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure readFail Data.Map.Internal.Tip Data.Map.Internal.Tip)-                                                                                                                                                                                                          )-                                                                                                                                                                                                          cs-                                                                                                                                                                                                          (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure readFail Data.Map.Internal.Tip Data.Map.Internal.Tip)-                                                                                                                                                                                                      else-                                                                                                                                                                                                        let _ = "checkToken.else"-                                                                                                                                                                                                         in let failExp =-                                                                                                                                                                                                                  Data.Set.Internal.Bin-                                                                                                                                                                                                                    1-                                                                                                                                                                                                                    ( Symantic.Parser.Grammar.Combinators.SomeFailure-                                                                                                                                                                                                                        ( case inputToken of-                                                                                                                                                                                                                            (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken ':'-                                                                                                                                                                                                                        )-                                                                                                                                                                                                                    )-                                                                                                                                                                                                                    Data.Set.Internal.Tip-                                                                                                                                                                                                                    Data.Set.Internal.Tip-                                                                                                                                                                                                             in let (#-                                                                                                                                                                                                                      farInp,-                                                                                                                                                                                                                      farExp-                                                                                                                                                                                                                      #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp inp of-                                                                                                                                                                                                                        GHC.Types.LT ->-                                                                                                                                                                                                                          (#-                                                                                                                                                                                                                            inp,-                                                                                                                                                                                                                            failExp-                                                                                                                                                                                                                          #)-                                                                                                                                                                                                                        GHC.Types.EQ ->-                                                                                                                                                                                                                          (#-                                                                                                                                                                                                                            farInp,-                                                                                                                                                                                                                            failExp GHC.Base.<> farExp-                                                                                                                                                                                                                          #)-                                                                                                                                                                                                                        GHC.Types.GT ->-                                                                                                                                                                                                                          (#-                                                                                                                                                                                                                            farInp,-                                                                                                                                                                                                                            farExp-                                                                                                                                                                                                                          #)-                                                                                                                                                                                                                 in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp-                                                                                                                                                                                              else-                                                                                                                                                                                                let _ = "checkHorizon.else"-                                                                                                                                                                                                 in let failExp =-                                                                                                                                                                                                          Data.Set.Internal.Bin-                                                                                                                                                                                                            1-                                                                                                                                                                                                            ( Symantic.Parser.Grammar.Combinators.SomeFailure-                                                                                                                                                                                                                ( case inputToken of-                                                                                                                                                                                                                    (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureHorizon @tok' 2-                                                                                                                                                                                                                )-                                                                                                                                                                                                            )-                                                                                                                                                                                                            Data.Set.Internal.Tip-                                                                                                                                                                                                            Data.Set.Internal.Tip-                                                                                                                                                                                                     in let (#-                                                                                                                                                                                                              farInp,-                                                                                                                                                                                                              farExp-                                                                                                                                                                                                              #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp inp of-                                                                                                                                                                                                                GHC.Types.LT ->-                                                                                                                                                                                                                  (#-                                                                                                                                                                                                                    inp,-                                                                                                                                                                                                                    failExp-                                                                                                                                                                                                                  #)-                                                                                                                                                                                                                GHC.Types.EQ ->-                                                                                                                                                                                                                  (#-                                                                                                                                                                                                                    farInp,-                                                                                                                                                                                                                    failExp GHC.Base.<> farExp-                                                                                                                                                                                                                  #)-                                                                                                                                                                                                                GHC.Types.GT ->-                                                                                                                                                                                                                  (#-                                                                                                                                                                                                                    farInp,-                                                                                                                                                                                                                    farExp-                                                                                                                                                                                                                  #)-                                                                                                                                                                                                         in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp-                                                                                                                                                                    )-                                                                                                                                                                    inp-                                                                                                                                                                    (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure catchHandler Data.Map.Internal.Tip Data.Map.Internal.Tip)-                                                                                                                                                          )-                                                                                                                                                          inp-                                                                                                                                                          (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure catchHandler Data.Map.Internal.Tip Data.Map.Internal.Tip)-                                                                                                                                                )-                                                                                                                                                inp-                                                                                                                                                (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure catchHandler Data.Map.Internal.Tip Data.Map.Internal.Tip)-                                                                                                                                      )-                                                                                                                                      cs-                                                                                                                                      Data.Map.Internal.Tip-                                                                                                                                  else-                                                                                                                                    let _ = "checkToken.else"-                                                                                                                                     in let failExp =-                                                                                                                                              Data.Set.Internal.Bin-                                                                                                                                                1-                                                                                                                                                ( Symantic.Parser.Grammar.Combinators.SomeFailure-                                                                                                                                                    ( case inputToken of-                                                                                                                                                        (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken 'n'-                                                                                                                                                    )-                                                                                                                                                )-                                                                                                                                                Data.Set.Internal.Tip-                                                                                                                                                Data.Set.Internal.Tip-                                                                                                                                         in let (#-                                                                                                                                                  farInp,-                                                                                                                                                  farExp-                                                                                                                                                  #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init cs of-                                                                                                                                                    GHC.Types.LT ->-                                                                                                                                                      (#-                                                                                                                                                        cs,-                                                                                                                                                        failExp-                                                                                                                                                      #)-                                                                                                                                                    GHC.Types.EQ ->-                                                                                                                                                      (#-                                                                                                                                                        init,-                                                                                                                                                        failExp GHC.Base.<> Data.Set.Internal.empty-                                                                                                                                                      #)-                                                                                                                                                    GHC.Types.GT ->-                                                                                                                                                      (#-                                                                                                                                                        init,-                                                                                                                                                        Data.Set.Internal.empty-                                                                                                                                                      #)-                                                                                                                                             in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure cs farInp farExp-                                                                                                                      else-                                                                                                                        let _ = "checkToken.else"-                                                                                                                         in let failExp =-                                                                                                                                  Data.Set.Internal.Bin-                                                                                                                                    1-                                                                                                                                    ( Symantic.Parser.Grammar.Combinators.SomeFailure-                                                                                                                                        ( case inputToken of-                                                                                                                                            (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken 'o'-                                                                                                                                        )-                                                                                                                                    )-                                                                                                                                    Data.Set.Internal.Tip-                                                                                                                                    Data.Set.Internal.Tip-                                                                                                                             in let (#-                                                                                                                                      farInp,-                                                                                                                                      farExp-                                                                                                                                      #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init cs of-                                                                                                                                        GHC.Types.LT ->-                                                                                                                                          (#-                                                                                                                                            cs,-                                                                                                                                            failExp-                                                                                                                                          #)-                                                                                                                                        GHC.Types.EQ ->-                                                                                                                                          (#-                                                                                                                                            init,-                                                                                                                                            failExp GHC.Base.<> Data.Set.Internal.empty-                                                                                                                                          #)-                                                                                                                                        GHC.Types.GT ->-                                                                                                                                          (#-                                                                                                                                            init,-                                                                                                                                            Data.Set.Internal.empty-                                                                                                                                          #)-                                                                                                                                 in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure cs farInp farExp-                                                                                                          else-                                                                                                            let _ = "checkToken.else"-                                                                                                             in let failExp =-                                                                                                                      Data.Set.Internal.Bin-                                                                                                                        1-                                                                                                                        ( Symantic.Parser.Grammar.Combinators.SomeFailure-                                                                                                                            ( case inputToken of-                                                                                                                                (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken 'i'-                                                                                                                            )-                                                                                                                        )-                                                                                                                        Data.Set.Internal.Tip-                                                                                                                        Data.Set.Internal.Tip-                                                                                                                 in let (#-                                                                                                                          farInp,-                                                                                                                          farExp-                                                                                                                          #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init cs of-                                                                                                                            GHC.Types.LT ->-                                                                                                                              (#-                                                                                                                                cs,-                                                                                                                                failExp-                                                                                                                              #)-                                                                                                                            GHC.Types.EQ ->-                                                                                                                              (#-                                                                                                                                init,-                                                                                                                                failExp GHC.Base.<> Data.Set.Internal.empty-                                                                                                                              #)-                                                                                                                            GHC.Types.GT ->-                                                                                                                              (#-                                                                                                                                init,-                                                                                                                                Data.Set.Internal.empty-                                                                                                                              #)-                                                                                                                     in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure cs farInp farExp-                                                                                              else-                                                                                                let _ = "checkToken.else"-                                                                                                 in let failExp =-                                                                                                          Data.Set.Internal.Bin-                                                                                                            1-                                                                                                            ( Symantic.Parser.Grammar.Combinators.SomeFailure-                                                                                                                ( case inputToken of-                                                                                                                    (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken 't'-                                                                                                                )-                                                                                                            )-                                                                                                            Data.Set.Internal.Tip-                                                                                                            Data.Set.Internal.Tip-                                                                                                     in let (#-                                                                                                              farInp,-                                                                                                              farExp-                                                                                                              #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init cs of-                                                                                                                GHC.Types.LT ->-                                                                                                                  (#-                                                                                                                    cs,-                                                                                                                    failExp-                                                                                                                  #)-                                                                                                                GHC.Types.EQ ->-                                                                                                                  (#-                                                                                                                    init,-                                                                                                                    failExp GHC.Base.<> Data.Set.Internal.empty-                                                                                                                  #)-                                                                                                                GHC.Types.GT ->-                                                                                                                  (#-                                                                                                                    init,-                                                                                                                    Data.Set.Internal.empty-                                                                                                                  #)-                                                                                                         in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure cs farInp farExp-                                                                                  else-                                                                                    let _ = "checkToken.else"-                                                                                     in let failExp =-                                                                                              Data.Set.Internal.Bin-                                                                                                1-                                                                                                ( Symantic.Parser.Grammar.Combinators.SomeFailure-                                                                                                    ( case inputToken of-                                                                                                        (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken 'c'-                                                                                                    )-                                                                                                )-                                                                                                Data.Set.Internal.Tip-                                                                                                Data.Set.Internal.Tip-                                                                                         in let (#-                                                                                                  farInp,-                                                                                                  farExp-                                                                                                  #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init cs of-                                                                                                    GHC.Types.LT ->-                                                                                                      (#-                                                                                                        cs,-                                                                                                        failExp-                                                                                                      #)-                                                                                                    GHC.Types.EQ ->-                                                                                                      (#-                                                                                                        init,-                                                                                                        failExp GHC.Base.<> Data.Set.Internal.empty-                                                                                                      #)-                                                                                                    GHC.Types.GT ->-                                                                                                      (#-                                                                                                        init,-                                                                                                        Data.Set.Internal.empty-                                                                                                      #)-                                                                                             in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure cs farInp farExp-                                                                      else-                                                                        let _ = "checkToken.else"-                                                                         in let failExp =-                                                                                  Data.Set.Internal.Bin-                                                                                    1-                                                                                    ( Symantic.Parser.Grammar.Combinators.SomeFailure-                                                                                        ( case inputToken of-                                                                                            (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken 'n'-                                                                                        )-                                                                                    )-                                                                                    Data.Set.Internal.Tip-                                                                                    Data.Set.Internal.Tip-                                                                             in let (#-                                                                                      farInp,-                                                                                      farExp-                                                                                      #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init cs of-                                                                                        GHC.Types.LT ->-                                                                                          (#-                                                                                            cs,-                                                                                            failExp-                                                                                          #)-                                                                                        GHC.Types.EQ ->-                                                                                          (#-                                                                                            init,-                                                                                            failExp GHC.Base.<> Data.Set.Internal.empty-                                                                                          #)-                                                                                        GHC.Types.GT ->-                                                                                          (#-                                                                                            init,-                                                                                            Data.Set.Internal.empty-                                                                                          #)-                                                                                 in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure cs farInp farExp-                                                          else-                                                            let _ = "checkToken.else"-                                                             in let failExp =-                                                                      Data.Set.Internal.Bin-                                                                        1-                                                                        ( Symantic.Parser.Grammar.Combinators.SomeFailure-                                                                            ( case inputToken of-                                                                                (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken 'u'-                                                                            )-                                                                        )-                                                                        Data.Set.Internal.Tip-                                                                        Data.Set.Internal.Tip-                                                                 in let (#-                                                                          farInp,-                                                                          farExp-                                                                          #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init cs of-                                                                            GHC.Types.LT ->-                                                                              (#-                                                                                cs,-                                                                                failExp-                                                                              #)-                                                                            GHC.Types.EQ ->-                                                                              (#-                                                                                init,-                                                                                failExp GHC.Base.<> Data.Set.Internal.empty-                                                                              #)-                                                                            GHC.Types.GT ->-                                                                              (#-                                                                                init,-                                                                                Data.Set.Internal.empty-                                                                              #)-                                                                     in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure cs farInp farExp-                                              else-                                                let _ = "checkToken.else"-                                                 in let failExp =-                                                          Data.Set.Internal.Bin-                                                            1-                                                            ( Symantic.Parser.Grammar.Combinators.SomeFailure-                                                                ( case inputToken of-                                                                    (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken 'f'-                                                                )-                                                            )-                                                            Data.Set.Internal.Tip-                                                            Data.Set.Internal.Tip-                                                     in let (#-                                                              farInp,-                                                              farExp-                                                              #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init inp of-                                                                GHC.Types.LT ->-                                                                  (#-                                                                    inp,-                                                                    failExp-                                                                  #)-                                                                GHC.Types.EQ ->-                                                                  (#-                                                                    init,-                                                                    failExp GHC.Base.<> Data.Set.Internal.empty-                                                                  #)-                                                                GHC.Types.GT ->-                                                                  (#-                                                                    init,-                                                                    Data.Set.Internal.empty-                                                                  #)-                                                         in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp-                                      else-                                        let _ = "checkHorizon.else"-                                         in let failExp =-                                                  Data.Set.Internal.Bin-                                                    1-                                                    ( Symantic.Parser.Grammar.Combinators.SomeFailure-                                                        ( case inputToken of-                                                            (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureHorizon @tok' 18-                                                        )-                                                    )-                                                    Data.Set.Internal.Tip-                                                    Data.Set.Internal.Tip-                                             in let (#-                                                      farInp,-                                                      farExp-                                                      #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init inp of-                                                        GHC.Types.LT ->-                                                          (#-                                                            inp,-                                                            failExp-                                                          #)-                                                        GHC.Types.EQ ->-                                                          (#-                                                            init,-                                                            failExp GHC.Base.<> Data.Set.Internal.empty-                                                          #)-                                                        GHC.Types.GT ->-                                                          (#-                                                            init,-                                                            Data.Set.Internal.empty-                                                          #)-                                                 in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp-              name = \(!ok) (!inp) (!koByLabel) ->-                let _ = "resume"-                 in ok-                      init-                      Data.Set.Internal.empty-                      ( let _ = "resume.genCode"-                         in GHC.Tuple . ()-                      )-                      inp-              name = \(!ok) (!inp) (!koByLabel) ->-                let _ = "resume"-                 in ok-                      init-                      Data.Set.Internal.empty-                      ( let _ = "resume.genCode"-                         in GHC.Tuple . ()-                      )-                      inp-              name = \(!ok) (!inp) (!koByLabel) ->-                let _ = "resume"-                 in ok-                      init-                      Data.Set.Internal.empty-                      ( let _ = "resume.genCode"-                         in \x -> \x -> x-                      )-                      inp-           in name-                ( let _ = "suspend"-                   in \farInp farExp v (!inp) ->-                        name-                          ( let _ = "suspend"-                             in \farInp farExp v (!inp) ->-                                  name-                                    ( let _ = "suspend"-                                       in \farInp farExp v (!inp) ->-                                            name-                                              ( let _ = "suspend"-                                                 in \farInp farExp v (!inp) ->-                                                      let join = \farInp farExp v (!inp) ->-                                                            let _ = "resume"-                                                             in finalRet-                                                                  farInp-                                                                  farExp-                                                                  ( let _ = "resume.genCode"-                                                                     in GHC.Show.show v-                                                                  )-                                                                  inp-                                                       in let _ = "catch ExceptionFailure"-                                                           in let catchHandler (!_exn) (!failInp) (!farInp) (!farExp) =-                                                                    let _ = "catch.ko ExceptionFailure"-                                                                     in if ( \( Data.Text.Internal.Text-                                                                                  _-                                                                                  i-                                                                                  _-                                                                                )-                                                                              ( Data.Text.Internal.Text-                                                                                  _-                                                                                  j-                                                                                  _-                                                                                ) -> i GHC.Classes.== j-                                                                           )-                                                                          inp-                                                                          failInp-                                                                          then-                                                                            let _ = "choicesBranch.then"-                                                                             in let failExp = Data.Set.Internal.Bin 1 (Symantic.Parser.Grammar.Combinators.SomeFailure Symantic.Parser.Grammar.Combinators.FailureEnd) Data.Set.Internal.Tip Data.Set.Internal.Tip-                                                                                 in let (#-                                                                                          farInp,-                                                                                          farExp-                                                                                          #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp failInp of-                                                                                            GHC.Types.LT ->-                                                                                              (#-                                                                                                failInp,-                                                                                                failExp-                                                                                              #)-                                                                                            GHC.Types.EQ ->-                                                                                              (#-                                                                                                farInp,-                                                                                                failExp GHC.Base.<> farExp-                                                                                              #)-                                                                                            GHC.Types.GT ->-                                                                                              (#-                                                                                                farInp,-                                                                                                farExp-                                                                                              #)-                                                                                     in finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp farInp farExp-                                                                          else-                                                                            let _ = "choicesBranch.else"-                                                                             in finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp farInp farExp-                                                               in let _ = "catch ExceptionFailure"-                                                                   in let catchHandler (!_exn) (!failInp) (!farInp) (!farExp) =-                                                                            let _ = "catch.ko ExceptionFailure"-                                                                             in let _ = "resume"-                                                                                 in join-                                                                                      farInp-                                                                                      farExp-                                                                                      ( let _ = "resume.genCode"-                                                                                         in GHC.Tuple . ()-                                                                                      )-                                                                                      inp-                                                                       in let readFail = catchHandler-                                                                           in if readMore inp-                                                                                then-                                                                                  let !(#-                                                                                         c,-                                                                                         cs-                                                                                         #) = readNext inp-                                                                                   in catchHandler Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp-                                                                                else-                                                                                  let _ = "checkHorizon.else"-                                                                                   in let failExp =-                                                                                            Data.Set.Internal.Bin-                                                                                              1-                                                                                              ( Symantic.Parser.Grammar.Combinators.SomeFailure-                                                                                                  ( case inputToken of-                                                                                                      (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureHorizon @tok' 1-                                                                                                  )-                                                                                              )-                                                                                              Data.Set.Internal.Tip-                                                                                              Data.Set.Internal.Tip-                                                                                       in let (#-                                                                                                farInp,-                                                                                                farExp-                                                                                                #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp inp of-                                                                                                  GHC.Types.LT ->-                                                                                                    (#-                                                                                                      inp,-                                                                                                      failExp-                                                                                                    #)-                                                                                                  GHC.Types.EQ ->-                                                                                                    (#-                                                                                                      farInp,-                                                                                                      failExp GHC.Base.<> farExp-                                                                                                    #)-                                                                                                  GHC.Types.GT ->-                                                                                                    (#-                                                                                                      farInp,-                                                                                                      farExp-                                                                                                    #)-                                                                                           in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp-                                              )-                                              inp-                                              Data.Map.Internal.Tip-                                    )-                                    inp-                                    Data.Map.Internal.Tip-                          )-                          inp-                          Data.Map.Internal.Tip-                )-                init-                Data.Map.Internal.Tip
− test/Golden/Splice/G15.expected.txt 
@@ -1,316 +0,0 @@-\(input :: inp) ->-  let !(#-         init,-         readMore,-         readNext-         #) =-          let _ = "cursorOf"-           in let next-                    ( t@( Data.Text.Internal.Text-                            arr-                            off-                            unconsumed-                          )-                      ) =-                      let !( Data.Text.Unsafe.Iter-                               c-                               d-                             ) = Data.Text.Unsafe.iter t 0-                       in (#-                            c,-                            Data.Text.Internal.Text arr (off GHC.Num.+ d) (unconsumed GHC.Num.- d)-                          #)-                  more-                    ( Data.Text.Internal.Text-                        _-                        _-                        unconsumed-                      ) = unconsumed GHC.Classes.> 0-               in (# input, more, next #)-      finalRet = \_farInp _farExp v _inp -> Data.Either.Right v-      finalRaise ::-        forall b.-        Symantic.Parser.Machine.Generate.Catcher-          inp-          b = \(!exn) _failInp (!farInp) (!farExp) ->-          Data.Either.Left-            Symantic.Parser.Machine.Generate.ParsingError-              { Symantic.Parser.Machine.Generate.parsingErrorOffset = Symantic.Parser.Machine.Input.offset farInp,-                Symantic.Parser.Machine.Generate.parsingErrorException = exn,-                Symantic.Parser.Machine.Generate.parsingErrorUnexpected =-                  if readMore farInp-                    then-                      GHC.Maybe.Just-                        ( let (#-                                c,-                                _-                                #) = readNext farInp-                           in c-                        )-                    else GHC.Maybe.Nothing,-                Symantic.Parser.Machine.Generate.parsingErrorExpecting = farExp-              }-   in let inputToken = Data.Proxy.Proxy :: Data.Proxy.Proxy (Symantic.Parser.Machine.Input.InputToken inp)-       in let-           in let join = \farInp farExp v (!inp) ->-                    let readFail = finalRaise-                     in if readMore inp-                          then-                            let !(#-                                   c,-                                   cs-                                   #) = readNext inp-                             in if (GHC.Classes.==) 'c' c-                                  then-                                    let _ = "resume"-                                     in finalRet-                                          farInp-                                          farExp-                                          ( let _ = "resume.genCode"-                                             in GHC.Show.show v-                                          )-                                          cs-                                  else-                                    let _ = "checkToken.else"-                                     in let failExp =-                                              Data.Set.Internal.Bin-                                                1-                                                ( Symantic.Parser.Grammar.Combinators.SomeFailure-                                                    ( case inputToken of-                                                        (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken 'c'-                                                    )-                                                )-                                                Data.Set.Internal.Tip-                                                Data.Set.Internal.Tip-                                         in let (#-                                                  farInp,-                                                  farExp-                                                  #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp inp of-                                                    GHC.Types.LT ->-                                                      (#-                                                        inp,-                                                        failExp-                                                      #)-                                                    GHC.Types.EQ ->-                                                      (#-                                                        farInp,-                                                        failExp GHC.Base.<> farExp-                                                      #)-                                                    GHC.Types.GT ->-                                                      (#-                                                        farInp,-                                                        farExp-                                                      #)-                                             in finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp-                          else-                            let _ = "checkHorizon.else"-                             in let failExp =-                                      Data.Set.Internal.Bin-                                        1-                                        ( Symantic.Parser.Grammar.Combinators.SomeFailure-                                            ( case inputToken of-                                                (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureHorizon @tok' 1-                                            )-                                        )-                                        Data.Set.Internal.Tip-                                        Data.Set.Internal.Tip-                                 in let (#-                                          farInp,-                                          farExp-                                          #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp inp of-                                            GHC.Types.LT ->-                                              (#-                                                inp,-                                                failExp-                                              #)-                                            GHC.Types.EQ ->-                                              (#-                                                farInp,-                                                failExp GHC.Base.<> farExp-                                              #)-                                            GHC.Types.GT ->-                                              (#-                                                farInp,-                                                farExp-                                              #)-                                     in finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp-               in let _ = "catch ExceptionFailure"-                   in let catchHandler (!_exn) (!failInp) (!farInp) (!farExp) =-                            let _ = "catch.ko ExceptionFailure"-                             in if ( \( Data.Text.Internal.Text-                                          _-                                          i-                                          _-                                        )-                                      ( Data.Text.Internal.Text-                                          _-                                          j-                                          _-                                        ) -> i GHC.Classes.== j-                                   )-                                  init-                                  failInp-                                  then-                                    let _ = "choicesBranch.then"-                                     in let readFail = finalRaise-                                         in if readMore (Symantic.Parser.Machine.Input.shiftRightText 1 failInp)-                                              then-                                                let !(#-                                                       c,-                                                       cs-                                                       #) = readNext failInp-                                                 in if (GHC.Classes.==) 'b' c-                                                      then-                                                        let _ = "resume"-                                                         in join-                                                              farInp-                                                              farExp-                                                              ( let _ = "resume.genCode"-                                                                 in 'b'-                                                              )-                                                              cs-                                                      else-                                                        let _ = "checkToken.else"-                                                         in let failExp =-                                                                  Data.Set.Internal.Bin-                                                                    1-                                                                    ( Symantic.Parser.Grammar.Combinators.SomeFailure-                                                                        ( case inputToken of-                                                                            (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken 'b'-                                                                        )-                                                                    )-                                                                    Data.Set.Internal.Tip-                                                                    Data.Set.Internal.Tip-                                                             in let (#-                                                                      farInp,-                                                                      farExp-                                                                      #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp failInp of-                                                                        GHC.Types.LT ->-                                                                          (#-                                                                            failInp,-                                                                            failExp-                                                                          #)-                                                                        GHC.Types.EQ ->-                                                                          (#-                                                                            farInp,-                                                                            failExp GHC.Base.<> farExp-                                                                          #)-                                                                        GHC.Types.GT ->-                                                                          (#-                                                                            farInp,-                                                                            farExp-                                                                          #)-                                                                 in finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp farInp farExp-                                              else-                                                let _ = "checkHorizon.else"-                                                 in let failExp =-                                                          Data.Set.Internal.Bin-                                                            1-                                                            ( Symantic.Parser.Grammar.Combinators.SomeFailure-                                                                ( case inputToken of-                                                                    (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureHorizon @tok' 2-                                                                )-                                                            )-                                                            Data.Set.Internal.Tip-                                                            Data.Set.Internal.Tip-                                                     in let (#-                                                              farInp,-                                                              farExp-                                                              #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp failInp of-                                                                GHC.Types.LT ->-                                                                  (#-                                                                    failInp,-                                                                    failExp-                                                                  #)-                                                                GHC.Types.EQ ->-                                                                  (#-                                                                    farInp,-                                                                    failExp GHC.Base.<> farExp-                                                                  #)-                                                                GHC.Types.GT ->-                                                                  (#-                                                                    farInp,-                                                                    farExp-                                                                  #)-                                                         in finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp farInp farExp-                                  else-                                    let _ = "choicesBranch.else"-                                     in finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp farInp farExp-                       in let readFail = catchHandler-                           in if readMore (Symantic.Parser.Machine.Input.shiftRightText 1 init)-                                then-                                  let !(# c, cs #) = readNext init-                                   in if (GHC.Classes.==) 'a' c-                                        then-                                          let _ = "resume"-                                           in join-                                                init-                                                Data.Set.Internal.empty-                                                ( let _ = "resume.genCode"-                                                   in 'a'-                                                )-                                                cs-                                        else-                                          let _ = "checkToken.else"-                                           in let failExp =-                                                    Data.Set.Internal.Bin-                                                      1-                                                      ( Symantic.Parser.Grammar.Combinators.SomeFailure-                                                          ( case inputToken of-                                                              (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken 'a'-                                                          )-                                                      )-                                                      Data.Set.Internal.Tip-                                                      Data.Set.Internal.Tip-                                               in let (#-                                                        farInp,-                                                        farExp-                                                        #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init init of-                                                          GHC.Types.LT ->-                                                            (#-                                                              init,-                                                              failExp-                                                            #)-                                                          GHC.Types.EQ ->-                                                            (#-                                                              init,-                                                              failExp GHC.Base.<> Data.Set.Internal.empty-                                                            #)-                                                          GHC.Types.GT ->-                                                            (#-                                                              init,-                                                              Data.Set.Internal.empty-                                                            #)-                                                   in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure init farInp farExp-                                else-                                  let _ = "checkHorizon.else"-                                   in let failExp =-                                            Data.Set.Internal.Bin-                                              1-                                              ( Symantic.Parser.Grammar.Combinators.SomeFailure-                                                  ( case inputToken of-                                                      (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureHorizon @tok' 2-                                                  )-                                              )-                                              Data.Set.Internal.Tip-                                              Data.Set.Internal.Tip-                                       in let (#-                                                farInp,-                                                farExp-                                                #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init init of-                                                  GHC.Types.LT ->-                                                    (#-                                                      init,-                                                      failExp-                                                    #)-                                                  GHC.Types.EQ ->-                                                    (#-                                                      init,-                                                      failExp GHC.Base.<> Data.Set.Internal.empty-                                                    #)-                                                  GHC.Types.GT ->-                                                    (#-                                                      init,-                                                      Data.Set.Internal.empty-                                                    #)-                                           in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure init farInp farExp
− test/Golden/Splice/G16.expected.txt 
@@ -1,427 +0,0 @@-\(input :: inp) ->-  let !(#-         init,-         readMore,-         readNext-         #) =-          let _ = "cursorOf"-           in let next-                    ( t@( Data.Text.Internal.Text-                            arr-                            off-                            unconsumed-                          )-                      ) =-                      let !( Data.Text.Unsafe.Iter-                               c-                               d-                             ) = Data.Text.Unsafe.iter t 0-                       in (#-                            c,-                            Data.Text.Internal.Text arr (off GHC.Num.+ d) (unconsumed GHC.Num.- d)-                          #)-                  more-                    ( Data.Text.Internal.Text-                        _-                        _-                        unconsumed-                      ) = unconsumed GHC.Classes.> 0-               in (# input, more, next #)-      finalRet = \_farInp _farExp v _inp -> Data.Either.Right v-      finalRaise ::-        forall b.-        Symantic.Parser.Machine.Generate.Catcher-          inp-          b = \(!exn) _failInp (!farInp) (!farExp) ->-          Data.Either.Left-            Symantic.Parser.Machine.Generate.ParsingError-              { Symantic.Parser.Machine.Generate.parsingErrorOffset = Symantic.Parser.Machine.Input.offset farInp,-                Symantic.Parser.Machine.Generate.parsingErrorException = exn,-                Symantic.Parser.Machine.Generate.parsingErrorUnexpected =-                  if readMore farInp-                    then-                      GHC.Maybe.Just-                        ( let (#-                                c,-                                _-                                #) = readNext farInp-                           in c-                        )-                    else GHC.Maybe.Nothing,-                Symantic.Parser.Machine.Generate.parsingErrorExpecting = farExp-              }-   in let inputToken = Data.Proxy.Proxy :: Data.Proxy.Proxy (Symantic.Parser.Machine.Input.InputToken inp)-       in let-           in let join = \farInp farExp v (!inp) ->-                    let readFail = finalRaise-                     in if readMore inp-                          then-                            let !(#-                                   c,-                                   cs-                                   #) = readNext inp-                             in if (GHC.Classes.==) 'd' c-                                  then-                                    let _ = "resume"-                                     in finalRet-                                          farInp-                                          farExp-                                          ( let _ = "resume.genCode"-                                             in GHC.Show.show v-                                          )-                                          cs-                                  else-                                    let _ = "checkToken.else"-                                     in let failExp =-                                              Data.Set.Internal.Bin-                                                1-                                                ( Symantic.Parser.Grammar.Combinators.SomeFailure-                                                    ( case inputToken of-                                                        (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken 'd'-                                                    )-                                                )-                                                Data.Set.Internal.Tip-                                                Data.Set.Internal.Tip-                                         in let (#-                                                  farInp,-                                                  farExp-                                                  #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp inp of-                                                    GHC.Types.LT ->-                                                      (#-                                                        inp,-                                                        failExp-                                                      #)-                                                    GHC.Types.EQ ->-                                                      (#-                                                        farInp,-                                                        failExp GHC.Base.<> farExp-                                                      #)-                                                    GHC.Types.GT ->-                                                      (#-                                                        farInp,-                                                        farExp-                                                      #)-                                             in finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp-                          else-                            let _ = "checkHorizon.else"-                             in let failExp =-                                      Data.Set.Internal.Bin-                                        1-                                        ( Symantic.Parser.Grammar.Combinators.SomeFailure-                                            ( case inputToken of-                                                (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureHorizon @tok' 1-                                            )-                                        )-                                        Data.Set.Internal.Tip-                                        Data.Set.Internal.Tip-                                 in let (#-                                          farInp,-                                          farExp-                                          #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp inp of-                                            GHC.Types.LT ->-                                              (#-                                                inp,-                                                failExp-                                              #)-                                            GHC.Types.EQ ->-                                              (#-                                                farInp,-                                                failExp GHC.Base.<> farExp-                                              #)-                                            GHC.Types.GT ->-                                              (#-                                                farInp,-                                                farExp-                                              #)-                                     in finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp-               in let _ = "catch ExceptionFailure"-                   in let catchHandler (!_exn) (!failInp) (!farInp) (!farExp) =-                            let _ = "catch.ko ExceptionFailure"-                             in if ( \( Data.Text.Internal.Text-                                          _-                                          i-                                          _-                                        )-                                      ( Data.Text.Internal.Text-                                          _-                                          j-                                          _-                                        ) -> i GHC.Classes.== j-                                   )-                                  init-                                  failInp-                                  then-                                    let _ = "choicesBranch.then"-                                     in let readFail = finalRaise-                                         in if readMore (Symantic.Parser.Machine.Input.shiftRightText 1 failInp)-                                              then-                                                let !(#-                                                       c,-                                                       cs-                                                       #) = readNext failInp-                                                 in if (GHC.Classes.==) 'c' c-                                                      then-                                                        let _ = "resume"-                                                         in join-                                                              farInp-                                                              farExp-                                                              ( let _ = "resume.genCode"-                                                                 in 'c'-                                                              )-                                                              cs-                                                      else-                                                        let _ = "checkToken.else"-                                                         in let failExp =-                                                                  Data.Set.Internal.Bin-                                                                    1-                                                                    ( Symantic.Parser.Grammar.Combinators.SomeFailure-                                                                        ( case inputToken of-                                                                            (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken 'c'-                                                                        )-                                                                    )-                                                                    Data.Set.Internal.Tip-                                                                    Data.Set.Internal.Tip-                                                             in let (#-                                                                      farInp,-                                                                      farExp-                                                                      #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp failInp of-                                                                        GHC.Types.LT ->-                                                                          (#-                                                                            failInp,-                                                                            failExp-                                                                          #)-                                                                        GHC.Types.EQ ->-                                                                          (#-                                                                            farInp,-                                                                            failExp GHC.Base.<> farExp-                                                                          #)-                                                                        GHC.Types.GT ->-                                                                          (#-                                                                            farInp,-                                                                            farExp-                                                                          #)-                                                                 in finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp farInp farExp-                                              else-                                                let _ = "checkHorizon.else"-                                                 in let failExp =-                                                          Data.Set.Internal.Bin-                                                            1-                                                            ( Symantic.Parser.Grammar.Combinators.SomeFailure-                                                                ( case inputToken of-                                                                    (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureHorizon @tok' 2-                                                                )-                                                            )-                                                            Data.Set.Internal.Tip-                                                            Data.Set.Internal.Tip-                                                     in let (#-                                                              farInp,-                                                              farExp-                                                              #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp failInp of-                                                                GHC.Types.LT ->-                                                                  (#-                                                                    failInp,-                                                                    failExp-                                                                  #)-                                                                GHC.Types.EQ ->-                                                                  (#-                                                                    farInp,-                                                                    failExp GHC.Base.<> farExp-                                                                  #)-                                                                GHC.Types.GT ->-                                                                  (#-                                                                    farInp,-                                                                    farExp-                                                                  #)-                                                         in finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp farInp farExp-                                  else-                                    let _ = "choicesBranch.else"-                                     in finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp farInp farExp-                       in let join = \farInp farExp v (!inp) ->-                                let _ = "resume"-                                 in join-                                      farInp-                                      farExp-                                      ( let _ = "resume.genCode"-                                         in v-                                      )-                                      inp-                           in let _ = "catch ExceptionFailure"-                               in let catchHandler (!_exn) (!failInp) (!farInp) (!farExp) =-                                        let _ = "catch.ko ExceptionFailure"-                                         in if ( \( Data.Text.Internal.Text-                                                      _-                                                      i-                                                      _-                                                    )-                                                  ( Data.Text.Internal.Text-                                                      _-                                                      j-                                                      _-                                                    ) -> i GHC.Classes.== j-                                               )-                                              init-                                              failInp-                                              then-                                                let _ = "choicesBranch.then"-                                                 in let readFail = catchHandler-                                                     in if readMore (Symantic.Parser.Machine.Input.shiftRightText 1 failInp)-                                                          then-                                                            let !(#-                                                                   c,-                                                                   cs-                                                                   #) = readNext failInp-                                                             in if (GHC.Classes.==) 'b' c-                                                                  then-                                                                    let _ = "resume"-                                                                     in join-                                                                          farInp-                                                                          farExp-                                                                          ( let _ = "resume.genCode"-                                                                             in 'b'-                                                                          )-                                                                          cs-                                                                  else-                                                                    let _ = "checkToken.else"-                                                                     in let failExp =-                                                                              Data.Set.Internal.Bin-                                                                                1-                                                                                ( Symantic.Parser.Grammar.Combinators.SomeFailure-                                                                                    ( case inputToken of-                                                                                        (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken 'b'-                                                                                    )-                                                                                )-                                                                                Data.Set.Internal.Tip-                                                                                Data.Set.Internal.Tip-                                                                         in let (#-                                                                                  farInp,-                                                                                  farExp-                                                                                  #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp failInp of-                                                                                    GHC.Types.LT ->-                                                                                      (#-                                                                                        failInp,-                                                                                        failExp-                                                                                      #)-                                                                                    GHC.Types.EQ ->-                                                                                      (#-                                                                                        farInp,-                                                                                        failExp GHC.Base.<> farExp-                                                                                      #)-                                                                                    GHC.Types.GT ->-                                                                                      (#-                                                                                        farInp,-                                                                                        farExp-                                                                                      #)-                                                                             in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp farInp farExp-                                                          else-                                                            let _ = "checkHorizon.else"-                                                             in let failExp =-                                                                      Data.Set.Internal.Bin-                                                                        1-                                                                        ( Symantic.Parser.Grammar.Combinators.SomeFailure-                                                                            ( case inputToken of-                                                                                (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureHorizon @tok' 2-                                                                            )-                                                                        )-                                                                        Data.Set.Internal.Tip-                                                                        Data.Set.Internal.Tip-                                                                 in let (#-                                                                          farInp,-                                                                          farExp-                                                                          #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp failInp of-                                                                            GHC.Types.LT ->-                                                                              (#-                                                                                failInp,-                                                                                failExp-                                                                              #)-                                                                            GHC.Types.EQ ->-                                                                              (#-                                                                                farInp,-                                                                                failExp GHC.Base.<> farExp-                                                                              #)-                                                                            GHC.Types.GT ->-                                                                              (#-                                                                                farInp,-                                                                                farExp-                                                                              #)-                                                                     in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp farInp farExp-                                              else-                                                let _ = "choicesBranch.else"-                                                 in catchHandler Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp farInp farExp-                                   in let readFail = catchHandler-                                       in if readMore (Symantic.Parser.Machine.Input.shiftRightText 1 init)-                                            then-                                              let !(# c, cs #) = readNext init-                                               in if (GHC.Classes.==) 'a' c-                                                    then-                                                      let _ = "resume"-                                                       in join-                                                            init-                                                            Data.Set.Internal.empty-                                                            ( let _ = "resume.genCode"-                                                               in 'a'-                                                            )-                                                            cs-                                                    else-                                                      let _ = "checkToken.else"-                                                       in let failExp =-                                                                Data.Set.Internal.Bin-                                                                  1-                                                                  ( Symantic.Parser.Grammar.Combinators.SomeFailure-                                                                      ( case inputToken of-                                                                          (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken 'a'-                                                                      )-                                                                  )-                                                                  Data.Set.Internal.Tip-                                                                  Data.Set.Internal.Tip-                                                           in let (#-                                                                    farInp,-                                                                    farExp-                                                                    #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init init of-                                                                      GHC.Types.LT ->-                                                                        (#-                                                                          init,-                                                                          failExp-                                                                        #)-                                                                      GHC.Types.EQ ->-                                                                        (#-                                                                          init,-                                                                          failExp GHC.Base.<> Data.Set.Internal.empty-                                                                        #)-                                                                      GHC.Types.GT ->-                                                                        (#-                                                                          init,-                                                                          Data.Set.Internal.empty-                                                                        #)-                                                               in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure init farInp farExp-                                            else-                                              let _ = "checkHorizon.else"-                                               in let failExp =-                                                        Data.Set.Internal.Bin-                                                          1-                                                          ( Symantic.Parser.Grammar.Combinators.SomeFailure-                                                              ( case inputToken of-                                                                  (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureHorizon @tok' 2-                                                              )-                                                          )-                                                          Data.Set.Internal.Tip-                                                          Data.Set.Internal.Tip-                                                   in let (#-                                                            farInp,-                                                            farExp-                                                            #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init init of-                                                              GHC.Types.LT ->-                                                                (#-                                                                  init,-                                                                  failExp-                                                                #)-                                                              GHC.Types.EQ ->-                                                                (#-                                                                  init,-                                                                  failExp GHC.Base.<> Data.Set.Internal.empty-                                                                #)-                                                              GHC.Types.GT ->-                                                                (#-                                                                  init,-                                                                  Data.Set.Internal.empty-                                                                #)-                                                       in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure init farInp farExp
− test/Golden/Splice/G2.expected.txt 
@@ -1,211 +0,0 @@-\(input :: inp) ->-  let !(#-         init,-         readMore,-         readNext-         #) =-          let _ = "cursorOf"-           in let next-                    ( t@( Data.Text.Internal.Text-                            arr-                            off-                            unconsumed-                          )-                      ) =-                      let !( Data.Text.Unsafe.Iter-                               c-                               d-                             ) = Data.Text.Unsafe.iter t 0-                       in (#-                            c,-                            Data.Text.Internal.Text arr (off GHC.Num.+ d) (unconsumed GHC.Num.- d)-                          #)-                  more-                    ( Data.Text.Internal.Text-                        _-                        _-                        unconsumed-                      ) = unconsumed GHC.Classes.> 0-               in (# input, more, next #)-      finalRet = \_farInp _farExp v _inp -> Data.Either.Right v-      finalRaise ::-        forall b.-        Symantic.Parser.Machine.Generate.Catcher-          inp-          b = \(!exn) _failInp (!farInp) (!farExp) ->-          Data.Either.Left-            Symantic.Parser.Machine.Generate.ParsingError-              { Symantic.Parser.Machine.Generate.parsingErrorOffset = Symantic.Parser.Machine.Input.offset farInp,-                Symantic.Parser.Machine.Generate.parsingErrorException = exn,-                Symantic.Parser.Machine.Generate.parsingErrorUnexpected =-                  if readMore farInp-                    then-                      GHC.Maybe.Just-                        ( let (#-                                c,-                                _-                                #) = readNext farInp-                           in c-                        )-                    else GHC.Maybe.Nothing,-                Symantic.Parser.Machine.Generate.parsingErrorExpecting = farExp-              }-   in let inputToken = Data.Proxy.Proxy :: Data.Proxy.Proxy (Symantic.Parser.Machine.Input.InputToken inp)-       in let-           in let _ = "catch ExceptionFailure"-               in let catchHandler (!_exn) (!failInp) (!farInp) (!farExp) =-                        let _ = "catch.ko ExceptionFailure"-                         in finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure init farInp farExp-                   in let readFail = catchHandler-                       in if readMore (Symantic.Parser.Machine.Input.shiftRightText 2 init)-                            then-                              let !(# c, cs #) = readNext init-                               in if (GHC.Classes.==) 'a' c-                                    then-                                      let readFail = readFail-                                       in let !(# c, cs #) = readNext cs-                                           in if (GHC.Classes.==) 'b' c-                                                then-                                                  let readFail = readFail-                                                   in let !(#-                                                             c,-                                                             cs-                                                             #) = readNext cs-                                                       in if (GHC.Classes.==) 'c' c-                                                            then-                                                              let _ = "resume"-                                                               in finalRet-                                                                    init-                                                                    Data.Set.Internal.empty-                                                                    ( let _ = "resume.genCode"-                                                                       in GHC.Show.show ((GHC.Types.:) 'a' ((GHC.Types.:) 'b' ((GHC.Types.:) 'c' GHC.Types . [])))-                                                                    )-                                                                    cs-                                                            else-                                                              let _ = "checkToken.else"-                                                               in let failExp =-                                                                        Data.Set.Internal.Bin-                                                                          1-                                                                          ( Symantic.Parser.Grammar.Combinators.SomeFailure-                                                                              ( case inputToken of-                                                                                  (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken 'c'-                                                                              )-                                                                          )-                                                                          Data.Set.Internal.Tip-                                                                          Data.Set.Internal.Tip-                                                                   in let (#-                                                                            farInp,-                                                                            farExp-                                                                            #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init cs of-                                                                              GHC.Types.LT ->-                                                                                (#-                                                                                  cs,-                                                                                  failExp-                                                                                #)-                                                                              GHC.Types.EQ ->-                                                                                (#-                                                                                  init,-                                                                                  failExp GHC.Base.<> Data.Set.Internal.empty-                                                                                #)-                                                                              GHC.Types.GT ->-                                                                                (#-                                                                                  init,-                                                                                  Data.Set.Internal.empty-                                                                                #)-                                                                       in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure cs farInp farExp-                                                else-                                                  let _ = "checkToken.else"-                                                   in let failExp =-                                                            Data.Set.Internal.Bin-                                                              1-                                                              ( Symantic.Parser.Grammar.Combinators.SomeFailure-                                                                  ( case inputToken of-                                                                      (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken 'b'-                                                                  )-                                                              )-                                                              Data.Set.Internal.Tip-                                                              Data.Set.Internal.Tip-                                                       in let (#-                                                                farInp,-                                                                farExp-                                                                #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init cs of-                                                                  GHC.Types.LT ->-                                                                    (#-                                                                      cs,-                                                                      failExp-                                                                    #)-                                                                  GHC.Types.EQ ->-                                                                    (#-                                                                      init,-                                                                      failExp GHC.Base.<> Data.Set.Internal.empty-                                                                    #)-                                                                  GHC.Types.GT ->-                                                                    (#-                                                                      init,-                                                                      Data.Set.Internal.empty-                                                                    #)-                                                           in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure cs farInp farExp-                                    else-                                      let _ = "checkToken.else"-                                       in let failExp =-                                                Data.Set.Internal.Bin-                                                  1-                                                  ( Symantic.Parser.Grammar.Combinators.SomeFailure-                                                      ( case inputToken of-                                                          (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken 'a'-                                                      )-                                                  )-                                                  Data.Set.Internal.Tip-                                                  Data.Set.Internal.Tip-                                           in let (#-                                                    farInp,-                                                    farExp-                                                    #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init init of-                                                      GHC.Types.LT ->-                                                        (#-                                                          init,-                                                          failExp-                                                        #)-                                                      GHC.Types.EQ ->-                                                        (#-                                                          init,-                                                          failExp GHC.Base.<> Data.Set.Internal.empty-                                                        #)-                                                      GHC.Types.GT ->-                                                        (#-                                                          init,-                                                          Data.Set.Internal.empty-                                                        #)-                                               in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure init farInp farExp-                            else-                              let _ = "checkHorizon.else"-                               in let failExp =-                                        Data.Set.Internal.Bin-                                          1-                                          ( Symantic.Parser.Grammar.Combinators.SomeFailure-                                              ( case inputToken of-                                                  (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureHorizon @tok' 3-                                              )-                                          )-                                          Data.Set.Internal.Tip-                                          Data.Set.Internal.Tip-                                   in let (#-                                            farInp,-                                            farExp-                                            #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init init of-                                              GHC.Types.LT ->-                                                (#-                                                  init,-                                                  failExp-                                                #)-                                              GHC.Types.EQ ->-                                                (#-                                                  init,-                                                  failExp GHC.Base.<> Data.Set.Internal.empty-                                                #)-                                              GHC.Types.GT ->-                                                (#-                                                  init,-                                                  Data.Set.Internal.empty-                                                #)-                                       in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure init farInp farExp
− test/Golden/Splice/G3.expected.txt 
@@ -1,184 +0,0 @@-\(input :: inp) ->-  let !(#-         init,-         readMore,-         readNext-         #) =-          let _ = "cursorOf"-           in let next-                    ( t@( Data.Text.Internal.Text-                            arr-                            off-                            unconsumed-                          )-                      ) =-                      let !( Data.Text.Unsafe.Iter-                               c-                               d-                             ) = Data.Text.Unsafe.iter t 0-                       in (#-                            c,-                            Data.Text.Internal.Text arr (off GHC.Num.+ d) (unconsumed GHC.Num.- d)-                          #)-                  more-                    ( Data.Text.Internal.Text-                        _-                        _-                        unconsumed-                      ) = unconsumed GHC.Classes.> 0-               in (# input, more, next #)-      finalRet = \_farInp _farExp v _inp -> Data.Either.Right v-      finalRaise ::-        forall b.-        Symantic.Parser.Machine.Generate.Catcher-          inp-          b = \(!exn) _failInp (!farInp) (!farExp) ->-          Data.Either.Left-            Symantic.Parser.Machine.Generate.ParsingError-              { Symantic.Parser.Machine.Generate.parsingErrorOffset = Symantic.Parser.Machine.Input.offset farInp,-                Symantic.Parser.Machine.Generate.parsingErrorException = exn,-                Symantic.Parser.Machine.Generate.parsingErrorUnexpected =-                  if readMore farInp-                    then-                      GHC.Maybe.Just-                        ( let (#-                                c,-                                _-                                #) = readNext farInp-                           in c-                        )-                    else GHC.Maybe.Nothing,-                Symantic.Parser.Machine.Generate.parsingErrorExpecting = farExp-              }-   in let inputToken = Data.Proxy.Proxy :: Data.Proxy.Proxy (Symantic.Parser.Machine.Input.InputToken inp)-       in let name = \(!ok) (!inp) (!koByLabel) ->-                let _ = "catch ExceptionFailure"-                 in let catchHandler (!_exn) (!failInp) (!farInp) (!farExp) =-                          let _ = "catch.ko ExceptionFailure"-                           in if ( \( Data.Text.Internal.Text-                                        _-                                        i-                                        _-                                      )-                                    ( Data.Text.Internal.Text-                                        _-                                        j-                                        _-                                      ) -> i GHC.Classes.== j-                                 )-                                inp-                                failInp-                                then-                                  let _ = "choicesBranch.then"-                                   in let _ = "resume"-                                       in ok-                                            farInp-                                            farExp-                                            ( let _ = "resume.genCode"-                                               in \x -> x-                                            )-                                            failInp-                                else-                                  let _ = "choicesBranch.else"-                                   in Data.Map.Strict.Internal.findWithDefault finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure koByLabel Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp farInp farExp-                     in let readFail = catchHandler-                         in if readMore inp-                              then-                                let !(#-                                       c,-                                       cs-                                       #) = readNext inp-                                 in if (GHC.Classes.==) 'a' c-                                      then-                                        name-                                          ( let _ = "suspend"-                                             in \farInp farExp v (!inp) ->-                                                  let _ = "resume"-                                                   in ok-                                                        farInp-                                                        farExp-                                                        ( let _ = "resume.genCode"-                                                           in \x -> (GHC.Types.:) 'a' (v x)-                                                        )-                                                        inp-                                          )-                                          cs-                                          (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure readFail Data.Map.Internal.Tip Data.Map.Internal.Tip)-                                      else-                                        let _ = "checkToken.else"-                                         in let failExp =-                                                  Data.Set.Internal.Bin-                                                    1-                                                    ( Symantic.Parser.Grammar.Combinators.SomeFailure-                                                        ( case inputToken of-                                                            (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken 'a'-                                                        )-                                                    )-                                                    Data.Set.Internal.Tip-                                                    Data.Set.Internal.Tip-                                             in let (#-                                                      farInp,-                                                      farExp-                                                      #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init inp of-                                                        GHC.Types.LT ->-                                                          (#-                                                            inp,-                                                            failExp-                                                          #)-                                                        GHC.Types.EQ ->-                                                          (#-                                                            init,-                                                            failExp GHC.Base.<> Data.Set.Internal.empty-                                                          #)-                                                        GHC.Types.GT ->-                                                          (#-                                                            init,-                                                            Data.Set.Internal.empty-                                                          #)-                                                 in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp-                              else-                                let _ = "checkHorizon.else"-                                 in let failExp =-                                          Data.Set.Internal.Bin-                                            1-                                            ( Symantic.Parser.Grammar.Combinators.SomeFailure-                                                ( case inputToken of-                                                    (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureHorizon @tok' 1-                                                )-                                            )-                                            Data.Set.Internal.Tip-                                            Data.Set.Internal.Tip-                                     in let (#-                                              farInp,-                                              farExp-                                              #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init inp of-                                                GHC.Types.LT ->-                                                  (#-                                                    inp,-                                                    failExp-                                                  #)-                                                GHC.Types.EQ ->-                                                  (#-                                                    init,-                                                    failExp GHC.Base.<> Data.Set.Internal.empty-                                                  #)-                                                GHC.Types.GT ->-                                                  (#-                                                    init,-                                                    Data.Set.Internal.empty-                                                  #)-                                         in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp-           in name-                ( let _ = "suspend"-                   in \farInp farExp v (!inp) ->-                        let _ = "resume"-                         in finalRet-                              farInp-                              farExp-                              ( let _ = "resume.genCode"-                                 in GHC.Show.show (v GHC.Types . [])-                              )-                              inp-                )-                init-                Data.Map.Internal.Tip
− test/Golden/Splice/G4.expected.txt 
@@ -1,326 +0,0 @@-\(input :: inp) ->-  let !(#-         init,-         readMore,-         readNext-         #) =-          let _ = "cursorOf"-           in let next-                    ( t@( Data.Text.Internal.Text-                            arr-                            off-                            unconsumed-                          )-                      ) =-                      let !( Data.Text.Unsafe.Iter-                               c-                               d-                             ) = Data.Text.Unsafe.iter t 0-                       in (#-                            c,-                            Data.Text.Internal.Text arr (off GHC.Num.+ d) (unconsumed GHC.Num.- d)-                          #)-                  more-                    ( Data.Text.Internal.Text-                        _-                        _-                        unconsumed-                      ) = unconsumed GHC.Classes.> 0-               in (# input, more, next #)-      finalRet = \_farInp _farExp v _inp -> Data.Either.Right v-      finalRaise ::-        forall b.-        Symantic.Parser.Machine.Generate.Catcher-          inp-          b = \(!exn) _failInp (!farInp) (!farExp) ->-          Data.Either.Left-            Symantic.Parser.Machine.Generate.ParsingError-              { Symantic.Parser.Machine.Generate.parsingErrorOffset = Symantic.Parser.Machine.Input.offset farInp,-                Symantic.Parser.Machine.Generate.parsingErrorException = exn,-                Symantic.Parser.Machine.Generate.parsingErrorUnexpected =-                  if readMore farInp-                    then-                      GHC.Maybe.Just-                        ( let (#-                                c,-                                _-                                #) = readNext farInp-                           in c-                        )-                    else GHC.Maybe.Nothing,-                Symantic.Parser.Machine.Generate.parsingErrorExpecting = farExp-              }-   in let inputToken = Data.Proxy.Proxy :: Data.Proxy.Proxy (Symantic.Parser.Machine.Input.InputToken inp)-       in let name = \(!ok) (!inp) (!koByLabel) ->-                let _ = "catch ExceptionFailure"-                 in let catchHandler (!_exn) (!failInp) (!farInp) (!farExp) =-                          let _ = "catch.ko ExceptionFailure"-                           in Data.Map.Strict.Internal.findWithDefault finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure koByLabel Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp-                     in let readFail = catchHandler-                         in if readMore (Symantic.Parser.Machine.Input.shiftRightText 3 inp)-                              then-                                let !(#-                                       c,-                                       cs-                                       #) = readNext inp-                                 in if (GHC.Classes.==) 'a' c-                                      then-                                        let readFail = readFail-                                         in let !(#-                                                   c,-                                                   cs-                                                   #) = readNext cs-                                             in if (GHC.Classes.==) 'b' c-                                                  then-                                                    let readFail = readFail-                                                     in let !(#-                                                               c,-                                                               cs-                                                               #) = readNext cs-                                                         in if (GHC.Classes.==) 'c' c-                                                              then-                                                                let readFail = readFail-                                                                 in let !(#-                                                                           c,-                                                                           cs-                                                                           #) = readNext cs-                                                                     in if (GHC.Classes.==) 'd' c-                                                                          then-                                                                            let _ = "resume"-                                                                             in ok-                                                                                  init-                                                                                  Data.Set.Internal.empty-                                                                                  ( let _ = "resume.genCode"-                                                                                     in (GHC.Types.:) 'a' ((GHC.Types.:) 'b' ((GHC.Types.:) 'c' ((GHC.Types.:) 'd' GHC.Types . [])))-                                                                                  )-                                                                                  cs-                                                                          else-                                                                            let _ = "checkToken.else"-                                                                             in let failExp =-                                                                                      Data.Set.Internal.Bin-                                                                                        1-                                                                                        ( Symantic.Parser.Grammar.Combinators.SomeFailure-                                                                                            ( case inputToken of-                                                                                                (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken 'd'-                                                                                            )-                                                                                        )-                                                                                        Data.Set.Internal.Tip-                                                                                        Data.Set.Internal.Tip-                                                                                 in let (#-                                                                                          farInp,-                                                                                          farExp-                                                                                          #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init cs of-                                                                                            GHC.Types.LT ->-                                                                                              (#-                                                                                                cs,-                                                                                                failExp-                                                                                              #)-                                                                                            GHC.Types.EQ ->-                                                                                              (#-                                                                                                init,-                                                                                                failExp GHC.Base.<> Data.Set.Internal.empty-                                                                                              #)-                                                                                            GHC.Types.GT ->-                                                                                              (#-                                                                                                init,-                                                                                                Data.Set.Internal.empty-                                                                                              #)-                                                                                     in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure cs farInp farExp-                                                              else-                                                                let _ = "checkToken.else"-                                                                 in let failExp =-                                                                          Data.Set.Internal.Bin-                                                                            1-                                                                            ( Symantic.Parser.Grammar.Combinators.SomeFailure-                                                                                ( case inputToken of-                                                                                    (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken 'c'-                                                                                )-                                                                            )-                                                                            Data.Set.Internal.Tip-                                                                            Data.Set.Internal.Tip-                                                                     in let (#-                                                                              farInp,-                                                                              farExp-                                                                              #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init cs of-                                                                                GHC.Types.LT ->-                                                                                  (#-                                                                                    cs,-                                                                                    failExp-                                                                                  #)-                                                                                GHC.Types.EQ ->-                                                                                  (#-                                                                                    init,-                                                                                    failExp GHC.Base.<> Data.Set.Internal.empty-                                                                                  #)-                                                                                GHC.Types.GT ->-                                                                                  (#-                                                                                    init,-                                                                                    Data.Set.Internal.empty-                                                                                  #)-                                                                         in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure cs farInp farExp-                                                  else-                                                    let _ = "checkToken.else"-                                                     in let failExp =-                                                              Data.Set.Internal.Bin-                                                                1-                                                                ( Symantic.Parser.Grammar.Combinators.SomeFailure-                                                                    ( case inputToken of-                                                                        (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken 'b'-                                                                    )-                                                                )-                                                                Data.Set.Internal.Tip-                                                                Data.Set.Internal.Tip-                                                         in let (#-                                                                  farInp,-                                                                  farExp-                                                                  #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init cs of-                                                                    GHC.Types.LT ->-                                                                      (#-                                                                        cs,-                                                                        failExp-                                                                      #)-                                                                    GHC.Types.EQ ->-                                                                      (#-                                                                        init,-                                                                        failExp GHC.Base.<> Data.Set.Internal.empty-                                                                      #)-                                                                    GHC.Types.GT ->-                                                                      (#-                                                                        init,-                                                                        Data.Set.Internal.empty-                                                                      #)-                                                             in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure cs farInp farExp-                                      else-                                        let _ = "checkToken.else"-                                         in let failExp =-                                                  Data.Set.Internal.Bin-                                                    1-                                                    ( Symantic.Parser.Grammar.Combinators.SomeFailure-                                                        ( case inputToken of-                                                            (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken 'a'-                                                        )-                                                    )-                                                    Data.Set.Internal.Tip-                                                    Data.Set.Internal.Tip-                                             in let (#-                                                      farInp,-                                                      farExp-                                                      #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init inp of-                                                        GHC.Types.LT ->-                                                          (#-                                                            inp,-                                                            failExp-                                                          #)-                                                        GHC.Types.EQ ->-                                                          (#-                                                            init,-                                                            failExp GHC.Base.<> Data.Set.Internal.empty-                                                          #)-                                                        GHC.Types.GT ->-                                                          (#-                                                            init,-                                                            Data.Set.Internal.empty-                                                          #)-                                                 in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp-                              else-                                let _ = "checkHorizon.else"-                                 in let failExp =-                                          Data.Set.Internal.Bin-                                            1-                                            ( Symantic.Parser.Grammar.Combinators.SomeFailure-                                                ( case inputToken of-                                                    (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureHorizon @tok' 4-                                                )-                                            )-                                            Data.Set.Internal.Tip-                                            Data.Set.Internal.Tip-                                     in let (#-                                              farInp,-                                              farExp-                                              #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init inp of-                                                GHC.Types.LT ->-                                                  (#-                                                    inp,-                                                    failExp-                                                  #)-                                                GHC.Types.EQ ->-                                                  (#-                                                    init,-                                                    failExp GHC.Base.<> Data.Set.Internal.empty-                                                  #)-                                                GHC.Types.GT ->-                                                  (#-                                                    init,-                                                    Data.Set.Internal.empty-                                                  #)-                                         in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp-              name = \(!ok) (!inp) (!koByLabel) ->-                let _ = "catch ExceptionFailure"-                 in let catchHandler (!_exn) (!failInp) (!farInp) (!farExp) =-                          let _ = "catch.ko ExceptionFailure"-                           in if ( \( Data.Text.Internal.Text-                                        _-                                        i-                                        _-                                      )-                                    ( Data.Text.Internal.Text-                                        _-                                        j-                                        _-                                      ) -> i GHC.Classes.== j-                                 )-                                inp-                                failInp-                                then-                                  let _ = "choicesBranch.then"-                                   in let _ = "resume"-                                       in ok-                                            farInp-                                            farExp-                                            ( let _ = "resume.genCode"-                                               in \x -> x-                                            )-                                            failInp-                                else-                                  let _ = "choicesBranch.else"-                                   in Data.Map.Strict.Internal.findWithDefault finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure koByLabel Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp farInp farExp-                     in name-                          ( let _ = "suspend"-                             in \farInp farExp v (!inp) ->-                                  name-                                    ( let _ = "suspend"-                                       in \farInp farExp v (!inp) ->-                                            let _ = "resume"-                                             in ok-                                                  farInp-                                                  farExp-                                                  ( let _ = "resume.genCode"-                                                     in \x -> (GHC.Types.:) v (v x)-                                                  )-                                                  inp-                                    )-                                    inp-                                    (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure catchHandler Data.Map.Internal.Tip Data.Map.Internal.Tip)-                          )-                          inp-                          (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure catchHandler Data.Map.Internal.Tip Data.Map.Internal.Tip)-           in name-                ( let _ = "suspend"-                   in \farInp farExp v (!inp) ->-                        name-                          ( let _ = "suspend"-                             in \farInp farExp v (!inp) ->-                                  let _ = "resume"-                                   in finalRet-                                        farInp-                                        farExp-                                        ( let _ = "resume.genCode"-                                           in GHC.Show.show ((GHC.Types.:) v (v GHC.Types . []))-                                        )-                                        inp-                          )-                          inp-                          Data.Map.Internal.Tip-                )-                init-                Data.Map.Internal.Tip
− test/Golden/Splice/G5.expected.txt 
@@ -1,420 +0,0 @@-\(input :: inp) ->-  let !(#-         init,-         readMore,-         readNext-         #) =-          let _ = "cursorOf"-           in let next-                    ( t@( Data.Text.Internal.Text-                            arr-                            off-                            unconsumed-                          )-                      ) =-                      let !( Data.Text.Unsafe.Iter-                               c-                               d-                             ) = Data.Text.Unsafe.iter t 0-                       in (#-                            c,-                            Data.Text.Internal.Text arr (off GHC.Num.+ d) (unconsumed GHC.Num.- d)-                          #)-                  more-                    ( Data.Text.Internal.Text-                        _-                        _-                        unconsumed-                      ) = unconsumed GHC.Classes.> 0-               in (# input, more, next #)-      finalRet = \_farInp _farExp v _inp -> Data.Either.Right v-      finalRaise ::-        forall b.-        Symantic.Parser.Machine.Generate.Catcher-          inp-          b = \(!exn) _failInp (!farInp) (!farExp) ->-          Data.Either.Left-            Symantic.Parser.Machine.Generate.ParsingError-              { Symantic.Parser.Machine.Generate.parsingErrorOffset = Symantic.Parser.Machine.Input.offset farInp,-                Symantic.Parser.Machine.Generate.parsingErrorException = exn,-                Symantic.Parser.Machine.Generate.parsingErrorUnexpected =-                  if readMore farInp-                    then-                      GHC.Maybe.Just-                        ( let (#-                                c,-                                _-                                #) = readNext farInp-                           in c-                        )-                    else GHC.Maybe.Nothing,-                Symantic.Parser.Machine.Generate.parsingErrorExpecting = farExp-              }-   in let inputToken = Data.Proxy.Proxy :: Data.Proxy.Proxy (Symantic.Parser.Machine.Input.InputToken inp)-       in let name = \(!ok) (!inp) (!koByLabel) ->-                let _ = "catch ExceptionFailure"-                 in let catchHandler (!_exn) (!failInp) (!farInp) (!farExp) =-                          let _ = "catch.ko ExceptionFailure"-                           in Data.Map.Strict.Internal.findWithDefault finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure koByLabel Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp-                     in let readFail = catchHandler-                         in if readMore (Symantic.Parser.Machine.Input.shiftRightText 3 inp)-                              then-                                let !(#-                                       c,-                                       cs-                                       #) = readNext inp-                                 in if (GHC.Classes.==) 'a' c-                                      then-                                        let readFail = readFail-                                         in let !(#-                                                   c,-                                                   cs-                                                   #) = readNext cs-                                             in if (GHC.Classes.==) 'b' c-                                                  then-                                                    let readFail = readFail-                                                     in let !(#-                                                               c,-                                                               cs-                                                               #) = readNext cs-                                                         in if (GHC.Classes.==) 'c' c-                                                              then-                                                                let readFail = readFail-                                                                 in let !(#-                                                                           c,-                                                                           cs-                                                                           #) = readNext cs-                                                                     in if (GHC.Classes.==) 'd' c-                                                                          then-                                                                            let _ = "resume"-                                                                             in ok-                                                                                  init-                                                                                  Data.Set.Internal.empty-                                                                                  ( let _ = "resume.genCode"-                                                                                     in (GHC.Types.:) 'a' ((GHC.Types.:) 'b' ((GHC.Types.:) 'c' ((GHC.Types.:) 'd' GHC.Types . [])))-                                                                                  )-                                                                                  cs-                                                                          else-                                                                            let _ = "checkToken.else"-                                                                             in let failExp =-                                                                                      Data.Set.Internal.Bin-                                                                                        1-                                                                                        ( Symantic.Parser.Grammar.Combinators.SomeFailure-                                                                                            ( case inputToken of-                                                                                                (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken 'd'-                                                                                            )-                                                                                        )-                                                                                        Data.Set.Internal.Tip-                                                                                        Data.Set.Internal.Tip-                                                                                 in let (#-                                                                                          farInp,-                                                                                          farExp-                                                                                          #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init cs of-                                                                                            GHC.Types.LT ->-                                                                                              (#-                                                                                                cs,-                                                                                                failExp-                                                                                              #)-                                                                                            GHC.Types.EQ ->-                                                                                              (#-                                                                                                init,-                                                                                                failExp GHC.Base.<> Data.Set.Internal.empty-                                                                                              #)-                                                                                            GHC.Types.GT ->-                                                                                              (#-                                                                                                init,-                                                                                                Data.Set.Internal.empty-                                                                                              #)-                                                                                     in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure cs farInp farExp-                                                              else-                                                                let _ = "checkToken.else"-                                                                 in let failExp =-                                                                          Data.Set.Internal.Bin-                                                                            1-                                                                            ( Symantic.Parser.Grammar.Combinators.SomeFailure-                                                                                ( case inputToken of-                                                                                    (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken 'c'-                                                                                )-                                                                            )-                                                                            Data.Set.Internal.Tip-                                                                            Data.Set.Internal.Tip-                                                                     in let (#-                                                                              farInp,-                                                                              farExp-                                                                              #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init cs of-                                                                                GHC.Types.LT ->-                                                                                  (#-                                                                                    cs,-                                                                                    failExp-                                                                                  #)-                                                                                GHC.Types.EQ ->-                                                                                  (#-                                                                                    init,-                                                                                    failExp GHC.Base.<> Data.Set.Internal.empty-                                                                                  #)-                                                                                GHC.Types.GT ->-                                                                                  (#-                                                                                    init,-                                                                                    Data.Set.Internal.empty-                                                                                  #)-                                                                         in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure cs farInp farExp-                                                  else-                                                    let _ = "checkToken.else"-                                                     in let failExp =-                                                              Data.Set.Internal.Bin-                                                                1-                                                                ( Symantic.Parser.Grammar.Combinators.SomeFailure-                                                                    ( case inputToken of-                                                                        (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken 'b'-                                                                    )-                                                                )-                                                                Data.Set.Internal.Tip-                                                                Data.Set.Internal.Tip-                                                         in let (#-                                                                  farInp,-                                                                  farExp-                                                                  #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init cs of-                                                                    GHC.Types.LT ->-                                                                      (#-                                                                        cs,-                                                                        failExp-                                                                      #)-                                                                    GHC.Types.EQ ->-                                                                      (#-                                                                        init,-                                                                        failExp GHC.Base.<> Data.Set.Internal.empty-                                                                      #)-                                                                    GHC.Types.GT ->-                                                                      (#-                                                                        init,-                                                                        Data.Set.Internal.empty-                                                                      #)-                                                             in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure cs farInp farExp-                                      else-                                        let _ = "checkToken.else"-                                         in let failExp =-                                                  Data.Set.Internal.Bin-                                                    1-                                                    ( Symantic.Parser.Grammar.Combinators.SomeFailure-                                                        ( case inputToken of-                                                            (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken 'a'-                                                        )-                                                    )-                                                    Data.Set.Internal.Tip-                                                    Data.Set.Internal.Tip-                                             in let (#-                                                      farInp,-                                                      farExp-                                                      #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init inp of-                                                        GHC.Types.LT ->-                                                          (#-                                                            inp,-                                                            failExp-                                                          #)-                                                        GHC.Types.EQ ->-                                                          (#-                                                            init,-                                                            failExp GHC.Base.<> Data.Set.Internal.empty-                                                          #)-                                                        GHC.Types.GT ->-                                                          (#-                                                            init,-                                                            Data.Set.Internal.empty-                                                          #)-                                                 in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp-                              else-                                let _ = "checkHorizon.else"-                                 in let failExp =-                                          Data.Set.Internal.Bin-                                            1-                                            ( Symantic.Parser.Grammar.Combinators.SomeFailure-                                                ( case inputToken of-                                                    (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureHorizon @tok' 4-                                                )-                                            )-                                            Data.Set.Internal.Tip-                                            Data.Set.Internal.Tip-                                     in let (#-                                              farInp,-                                              farExp-                                              #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init inp of-                                                GHC.Types.LT ->-                                                  (#-                                                    inp,-                                                    failExp-                                                  #)-                                                GHC.Types.EQ ->-                                                  (#-                                                    init,-                                                    failExp GHC.Base.<> Data.Set.Internal.empty-                                                  #)-                                                GHC.Types.GT ->-                                                  (#-                                                    init,-                                                    Data.Set.Internal.empty-                                                  #)-                                         in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp-              name = \(!ok) (!inp) (!koByLabel) ->-                let _ = "catch ExceptionFailure"-                 in let catchHandler (!_exn) (!failInp) (!farInp) (!farExp) =-                          let _ = "catch.ko ExceptionFailure"-                           in if ( \( Data.Text.Internal.Text-                                        _-                                        i-                                        _-                                      )-                                    ( Data.Text.Internal.Text-                                        _-                                        j-                                        _-                                      ) -> i GHC.Classes.== j-                                 )-                                inp-                                failInp-                                then-                                  let _ = "choicesBranch.then"-                                   in let _ = "resume"-                                       in ok-                                            farInp-                                            farExp-                                            ( let _ = "resume.genCode"-                                               in \x -> x-                                            )-                                            failInp-                                else-                                  let _ = "choicesBranch.else"-                                   in Data.Map.Strict.Internal.findWithDefault finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure koByLabel Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp farInp farExp-                     in name-                          ( let _ = "suspend"-                             in \farInp farExp v (!inp) ->-                                  name-                                    ( let _ = "suspend"-                                       in \farInp farExp v (!inp) ->-                                            let _ = "resume"-                                             in ok-                                                  farInp-                                                  farExp-                                                  ( let _ = "resume.genCode"-                                                     in \x -> (GHC.Types.:) v (v x)-                                                  )-                                                  inp-                                    )-                                    inp-                                    (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure catchHandler Data.Map.Internal.Tip Data.Map.Internal.Tip)-                          )-                          inp-                          (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure catchHandler Data.Map.Internal.Tip Data.Map.Internal.Tip)-           in name-                ( let _ = "suspend"-                   in \farInp farExp v (!inp) ->-                        name-                          ( let _ = "suspend"-                             in \farInp farExp v (!inp) ->-                                  let join = \farInp farExp v (!inp) ->-                                        let _ = "resume"-                                         in finalRet-                                              farInp-                                              farExp-                                              ( let _ = "resume.genCode"-                                                 in GHC.Show.show ((GHC.Types.:) v (v GHC.Types . []))-                                              )-                                              inp-                                   in let _ = "catch ExceptionFailure"-                                       in let catchHandler (!_exn) (!failInp) (!farInp) (!farExp) =-                                                let _ = "catch.ko ExceptionFailure"-                                                 in if ( \( Data.Text.Internal.Text-                                                              _-                                                              i-                                                              _-                                                            )-                                                          ( Data.Text.Internal.Text-                                                              _-                                                              j-                                                              _-                                                            ) -> i GHC.Classes.== j-                                                       )-                                                      inp-                                                      failInp-                                                      then-                                                        let _ = "choicesBranch.then"-                                                         in let failExp = Data.Set.Internal.Bin 1 (Symantic.Parser.Grammar.Combinators.SomeFailure Symantic.Parser.Grammar.Combinators.FailureEnd) Data.Set.Internal.Tip Data.Set.Internal.Tip-                                                             in let (#-                                                                      farInp,-                                                                      farExp-                                                                      #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp failInp of-                                                                        GHC.Types.LT ->-                                                                          (#-                                                                            failInp,-                                                                            failExp-                                                                          #)-                                                                        GHC.Types.EQ ->-                                                                          (#-                                                                            farInp,-                                                                            failExp GHC.Base.<> farExp-                                                                          #)-                                                                        GHC.Types.GT ->-                                                                          (#-                                                                            farInp,-                                                                            farExp-                                                                          #)-                                                                 in finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp farInp farExp-                                                      else-                                                        let _ = "choicesBranch.else"-                                                         in finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp farInp farExp-                                           in let _ = "catch ExceptionFailure"-                                               in let catchHandler (!_exn) (!failInp) (!farInp) (!farExp) =-                                                        let _ = "catch.ko ExceptionFailure"-                                                         in let _ = "resume"-                                                             in join-                                                                  farInp-                                                                  farExp-                                                                  ( let _ = "resume.genCode"-                                                                     in GHC.Tuple . ()-                                                                  )-                                                                  inp-                                                   in let readFail = catchHandler-                                                       in if readMore inp-                                                            then-                                                              let !(#-                                                                     c,-                                                                     cs-                                                                     #) = readNext inp-                                                               in catchHandler Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp-                                                            else-                                                              let _ = "checkHorizon.else"-                                                               in let failExp =-                                                                        Data.Set.Internal.Bin-                                                                          1-                                                                          ( Symantic.Parser.Grammar.Combinators.SomeFailure-                                                                              ( case inputToken of-                                                                                  (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureHorizon @tok' 1-                                                                              )-                                                                          )-                                                                          Data.Set.Internal.Tip-                                                                          Data.Set.Internal.Tip-                                                                   in let (#-                                                                            farInp,-                                                                            farExp-                                                                            #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp inp of-                                                                              GHC.Types.LT ->-                                                                                (#-                                                                                  inp,-                                                                                  failExp-                                                                                #)-                                                                              GHC.Types.EQ ->-                                                                                (#-                                                                                  farInp,-                                                                                  failExp GHC.Base.<> farExp-                                                                                #)-                                                                              GHC.Types.GT ->-                                                                                (#-                                                                                  farInp,-                                                                                  farExp-                                                                                #)-                                                                       in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp-                          )-                          inp-                          Data.Map.Internal.Tip-                )-                init-                Data.Map.Internal.Tip
− test/Golden/Splice/G6.expected.txt 
@@ -1,318 +0,0 @@-\(input :: inp) ->-  let !(#-         init,-         readMore,-         readNext-         #) =-          let _ = "cursorOf"-           in let next-                    ( t@( Data.Text.Internal.Text-                            arr-                            off-                            unconsumed-                          )-                      ) =-                      let !( Data.Text.Unsafe.Iter-                               c-                               d-                             ) = Data.Text.Unsafe.iter t 0-                       in (#-                            c,-                            Data.Text.Internal.Text arr (off GHC.Num.+ d) (unconsumed GHC.Num.- d)-                          #)-                  more-                    ( Data.Text.Internal.Text-                        _-                        _-                        unconsumed-                      ) = unconsumed GHC.Classes.> 0-               in (# input, more, next #)-      finalRet = \_farInp _farExp v _inp -> Data.Either.Right v-      finalRaise ::-        forall b.-        Symantic.Parser.Machine.Generate.Catcher-          inp-          b = \(!exn) _failInp (!farInp) (!farExp) ->-          Data.Either.Left-            Symantic.Parser.Machine.Generate.ParsingError-              { Symantic.Parser.Machine.Generate.parsingErrorOffset = Symantic.Parser.Machine.Input.offset farInp,-                Symantic.Parser.Machine.Generate.parsingErrorException = exn,-                Symantic.Parser.Machine.Generate.parsingErrorUnexpected =-                  if readMore farInp-                    then-                      GHC.Maybe.Just-                        ( let (#-                                c,-                                _-                                #) = readNext farInp-                           in c-                        )-                    else GHC.Maybe.Nothing,-                Symantic.Parser.Machine.Generate.parsingErrorExpecting = farExp-              }-   in let inputToken = Data.Proxy.Proxy :: Data.Proxy.Proxy (Symantic.Parser.Machine.Input.InputToken inp)-       in let-           in let join = \farInp farExp v (!inp) ->-                    let _ = "resume"-                     in finalRet-                          farInp-                          farExp-                          ( let _ = "resume.genCode"-                             in GHC.Show.show v-                          )-                          inp-               in let _ = "catch ExceptionFailure"-                   in let catchHandler (!_exn) (!failInp) (!farInp) (!farExp) =-                            let _ = "catch.ko ExceptionFailure"-                             in if ( \( Data.Text.Internal.Text-                                          _-                                          i-                                          _-                                        )-                                      ( Data.Text.Internal.Text-                                          _-                                          j-                                          _-                                        ) -> i GHC.Classes.== j-                                   )-                                  init-                                  failInp-                                  then-                                    let _ = "choicesBranch.then"-                                     in let readFail = finalRaise-                                         in if readMore (Symantic.Parser.Machine.Input.shiftRightText 1 failInp)-                                              then-                                                let !(#-                                                       c,-                                                       cs-                                                       #) = readNext failInp-                                                 in if (GHC.Classes.==) 'a' c-                                                      then-                                                        let readFail = finalRaise-                                                         in let !(#-                                                                   c,-                                                                   cs-                                                                   #) = readNext cs-                                                             in if (GHC.Classes.==) 'b' c-                                                                  then-                                                                    let _ = "resume"-                                                                     in join-                                                                          farInp-                                                                          farExp-                                                                          ( let _ = "resume.genCode"-                                                                             in (GHC.Types.:) 'a' ((GHC.Types.:) 'b' GHC.Types . [])-                                                                          )-                                                                          cs-                                                                  else-                                                                    let _ = "checkToken.else"-                                                                     in let failExp =-                                                                              Data.Set.Internal.Bin-                                                                                1-                                                                                ( Symantic.Parser.Grammar.Combinators.SomeFailure-                                                                                    ( case inputToken of-                                                                                        (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken 'b'-                                                                                    )-                                                                                )-                                                                                Data.Set.Internal.Tip-                                                                                Data.Set.Internal.Tip-                                                                         in let (#-                                                                                  farInp,-                                                                                  farExp-                                                                                  #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp cs of-                                                                                    GHC.Types.LT ->-                                                                                      (#-                                                                                        cs,-                                                                                        failExp-                                                                                      #)-                                                                                    GHC.Types.EQ ->-                                                                                      (#-                                                                                        farInp,-                                                                                        failExp GHC.Base.<> farExp-                                                                                      #)-                                                                                    GHC.Types.GT ->-                                                                                      (#-                                                                                        farInp,-                                                                                        farExp-                                                                                      #)-                                                                             in finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure cs farInp farExp-                                                      else-                                                        let _ = "checkToken.else"-                                                         in let failExp =-                                                                  Data.Set.Internal.Bin-                                                                    1-                                                                    ( Symantic.Parser.Grammar.Combinators.SomeFailure-                                                                        ( case inputToken of-                                                                            (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken 'a'-                                                                        )-                                                                    )-                                                                    Data.Set.Internal.Tip-                                                                    Data.Set.Internal.Tip-                                                             in let (#-                                                                      farInp,-                                                                      farExp-                                                                      #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp failInp of-                                                                        GHC.Types.LT ->-                                                                          (#-                                                                            failInp,-                                                                            failExp-                                                                          #)-                                                                        GHC.Types.EQ ->-                                                                          (#-                                                                            farInp,-                                                                            failExp GHC.Base.<> farExp-                                                                          #)-                                                                        GHC.Types.GT ->-                                                                          (#-                                                                            farInp,-                                                                            farExp-                                                                          #)-                                                                 in finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp farInp farExp-                                              else-                                                let _ = "checkHorizon.else"-                                                 in let failExp =-                                                          Data.Set.Internal.Bin-                                                            1-                                                            ( Symantic.Parser.Grammar.Combinators.SomeFailure-                                                                ( case inputToken of-                                                                    (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureHorizon @tok' 2-                                                                )-                                                            )-                                                            Data.Set.Internal.Tip-                                                            Data.Set.Internal.Tip-                                                     in let (#-                                                              farInp,-                                                              farExp-                                                              #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp failInp of-                                                                GHC.Types.LT ->-                                                                  (#-                                                                    failInp,-                                                                    failExp-                                                                  #)-                                                                GHC.Types.EQ ->-                                                                  (#-                                                                    farInp,-                                                                    failExp GHC.Base.<> farExp-                                                                  #)-                                                                GHC.Types.GT ->-                                                                  (#-                                                                    farInp,-                                                                    farExp-                                                                  #)-                                                         in finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp farInp farExp-                                  else-                                    let _ = "choicesBranch.else"-                                     in finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp farInp farExp-                       in let readFail = catchHandler-                           in if readMore (Symantic.Parser.Machine.Input.shiftRightText 1 init)-                                then-                                  let !(# c, cs #) = readNext init-                                   in if (GHC.Classes.==) 'a' c-                                        then-                                          let readFail = readFail-                                           in let !(# c, cs #) = readNext cs-                                               in if (GHC.Classes.==) 'a' c-                                                    then-                                                      let _ = "resume"-                                                       in join-                                                            init-                                                            Data.Set.Internal.empty-                                                            ( let _ = "resume.genCode"-                                                               in (GHC.Types.:) 'a' ((GHC.Types.:) 'a' GHC.Types . [])-                                                            )-                                                            cs-                                                    else-                                                      let _ = "checkToken.else"-                                                       in let failExp =-                                                                Data.Set.Internal.Bin-                                                                  1-                                                                  ( Symantic.Parser.Grammar.Combinators.SomeFailure-                                                                      ( case inputToken of-                                                                          (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken 'a'-                                                                      )-                                                                  )-                                                                  Data.Set.Internal.Tip-                                                                  Data.Set.Internal.Tip-                                                           in let (#-                                                                    farInp,-                                                                    farExp-                                                                    #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init cs of-                                                                      GHC.Types.LT ->-                                                                        (#-                                                                          cs,-                                                                          failExp-                                                                        #)-                                                                      GHC.Types.EQ ->-                                                                        (#-                                                                          init,-                                                                          failExp GHC.Base.<> Data.Set.Internal.empty-                                                                        #)-                                                                      GHC.Types.GT ->-                                                                        (#-                                                                          init,-                                                                          Data.Set.Internal.empty-                                                                        #)-                                                               in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure cs farInp farExp-                                        else-                                          let _ = "checkToken.else"-                                           in let failExp =-                                                    Data.Set.Internal.Bin-                                                      1-                                                      ( Symantic.Parser.Grammar.Combinators.SomeFailure-                                                          ( case inputToken of-                                                              (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken 'a'-                                                          )-                                                      )-                                                      Data.Set.Internal.Tip-                                                      Data.Set.Internal.Tip-                                               in let (#-                                                        farInp,-                                                        farExp-                                                        #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init init of-                                                          GHC.Types.LT ->-                                                            (#-                                                              init,-                                                              failExp-                                                            #)-                                                          GHC.Types.EQ ->-                                                            (#-                                                              init,-                                                              failExp GHC.Base.<> Data.Set.Internal.empty-                                                            #)-                                                          GHC.Types.GT ->-                                                            (#-                                                              init,-                                                              Data.Set.Internal.empty-                                                            #)-                                                   in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure init farInp farExp-                                else-                                  let _ = "checkHorizon.else"-                                   in let failExp =-                                            Data.Set.Internal.Bin-                                              1-                                              ( Symantic.Parser.Grammar.Combinators.SomeFailure-                                                  ( case inputToken of-                                                      (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureHorizon @tok' 2-                                                  )-                                              )-                                              Data.Set.Internal.Tip-                                              Data.Set.Internal.Tip-                                       in let (#-                                                farInp,-                                                farExp-                                                #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init init of-                                                  GHC.Types.LT ->-                                                    (#-                                                      init,-                                                      failExp-                                                    #)-                                                  GHC.Types.EQ ->-                                                    (#-                                                      init,-                                                      failExp GHC.Base.<> Data.Set.Internal.empty-                                                    #)-                                                  GHC.Types.GT ->-                                                    (#-                                                      init,-                                                      Data.Set.Internal.empty-                                                    #)-                                           in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure init farInp farExp
− test/Golden/Splice/G7.expected.txt 
@@ -1,329 +0,0 @@-\(input :: inp) ->-  let !(#-         init,-         readMore,-         readNext-         #) =-          let _ = "cursorOf"-           in let next-                    ( t@( Data.Text.Internal.Text-                            arr-                            off-                            unconsumed-                          )-                      ) =-                      let !( Data.Text.Unsafe.Iter-                               c-                               d-                             ) = Data.Text.Unsafe.iter t 0-                       in (#-                            c,-                            Data.Text.Internal.Text arr (off GHC.Num.+ d) (unconsumed GHC.Num.- d)-                          #)-                  more-                    ( Data.Text.Internal.Text-                        _-                        _-                        unconsumed-                      ) = unconsumed GHC.Classes.> 0-               in (# input, more, next #)-      finalRet = \_farInp _farExp v _inp -> Data.Either.Right v-      finalRaise ::-        forall b.-        Symantic.Parser.Machine.Generate.Catcher-          inp-          b = \(!exn) _failInp (!farInp) (!farExp) ->-          Data.Either.Left-            Symantic.Parser.Machine.Generate.ParsingError-              { Symantic.Parser.Machine.Generate.parsingErrorOffset = Symantic.Parser.Machine.Input.offset farInp,-                Symantic.Parser.Machine.Generate.parsingErrorException = exn,-                Symantic.Parser.Machine.Generate.parsingErrorUnexpected =-                  if readMore farInp-                    then-                      GHC.Maybe.Just-                        ( let (#-                                c,-                                _-                                #) = readNext farInp-                           in c-                        )-                    else GHC.Maybe.Nothing,-                Symantic.Parser.Machine.Generate.parsingErrorExpecting = farExp-              }-   in let inputToken = Data.Proxy.Proxy :: Data.Proxy.Proxy (Symantic.Parser.Machine.Input.InputToken inp)-       in let-           in let join = \farInp farExp v (!inp) ->-                    let _ = "resume"-                     in finalRet-                          farInp-                          farExp-                          ( let _ = "resume.genCode"-                             in GHC.Show.show v-                          )-                          inp-               in let _ = "catch ExceptionFailure"-                   in let catchHandler (!_exn) (!failInp) (!farInp) (!farExp) =-                            let _ = "catch.ko ExceptionFailure"-                             in if ( \( Data.Text.Internal.Text-                                          _-                                          i-                                          _-                                        )-                                      ( Data.Text.Internal.Text-                                          _-                                          j-                                          _-                                        ) -> i GHC.Classes.== j-                                   )-                                  init-                                  failInp-                                  then-                                    let _ = "choicesBranch.then"-                                     in let _ = "catch ExceptionFailure"-                                         in let catchHandler (!_exn) (!failInp) (!farInp) (!farExp) =-                                                  let _ = "catch.ko ExceptionFailure"-                                                   in finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp farInp farExp-                                             in let readFail = catchHandler-                                                 in if readMore (Symantic.Parser.Machine.Input.shiftRightText 1 failInp)-                                                      then-                                                        let !(#-                                                               c,-                                                               cs-                                                               #) = readNext failInp-                                                         in if (GHC.Classes.==) 'a' c-                                                              then-                                                                let readFail = readFail-                                                                 in let !(#-                                                                           c,-                                                                           cs-                                                                           #) = readNext cs-                                                                     in if (GHC.Classes.==) 'b' c-                                                                          then-                                                                            let _ = "resume"-                                                                             in join-                                                                                  farInp-                                                                                  farExp-                                                                                  ( let _ = "resume.genCode"-                                                                                     in (GHC.Types.:) 'a' ((GHC.Types.:) 'b' GHC.Types . [])-                                                                                  )-                                                                                  cs-                                                                          else-                                                                            let _ = "checkToken.else"-                                                                             in let failExp =-                                                                                      Data.Set.Internal.Bin-                                                                                        1-                                                                                        ( Symantic.Parser.Grammar.Combinators.SomeFailure-                                                                                            ( case inputToken of-                                                                                                (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken 'b'-                                                                                            )-                                                                                        )-                                                                                        Data.Set.Internal.Tip-                                                                                        Data.Set.Internal.Tip-                                                                                 in let (#-                                                                                          farInp,-                                                                                          farExp-                                                                                          #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp cs of-                                                                                            GHC.Types.LT ->-                                                                                              (#-                                                                                                cs,-                                                                                                failExp-                                                                                              #)-                                                                                            GHC.Types.EQ ->-                                                                                              (#-                                                                                                farInp,-                                                                                                failExp GHC.Base.<> farExp-                                                                                              #)-                                                                                            GHC.Types.GT ->-                                                                                              (#-                                                                                                farInp,-                                                                                                farExp-                                                                                              #)-                                                                                     in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure cs farInp farExp-                                                              else-                                                                let _ = "checkToken.else"-                                                                 in let failExp =-                                                                          Data.Set.Internal.Bin-                                                                            1-                                                                            ( Symantic.Parser.Grammar.Combinators.SomeFailure-                                                                                ( case inputToken of-                                                                                    (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken 'a'-                                                                                )-                                                                            )-                                                                            Data.Set.Internal.Tip-                                                                            Data.Set.Internal.Tip-                                                                     in let (#-                                                                              farInp,-                                                                              farExp-                                                                              #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp failInp of-                                                                                GHC.Types.LT ->-                                                                                  (#-                                                                                    failInp,-                                                                                    failExp-                                                                                  #)-                                                                                GHC.Types.EQ ->-                                                                                  (#-                                                                                    farInp,-                                                                                    failExp GHC.Base.<> farExp-                                                                                  #)-                                                                                GHC.Types.GT ->-                                                                                  (#-                                                                                    farInp,-                                                                                    farExp-                                                                                  #)-                                                                         in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp farInp farExp-                                                      else-                                                        let _ = "checkHorizon.else"-                                                         in let failExp =-                                                                  Data.Set.Internal.Bin-                                                                    1-                                                                    ( Symantic.Parser.Grammar.Combinators.SomeFailure-                                                                        ( case inputToken of-                                                                            (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureHorizon @tok' 2-                                                                        )-                                                                    )-                                                                    Data.Set.Internal.Tip-                                                                    Data.Set.Internal.Tip-                                                             in let (#-                                                                      farInp,-                                                                      farExp-                                                                      #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp failInp of-                                                                        GHC.Types.LT ->-                                                                          (#-                                                                            failInp,-                                                                            failExp-                                                                          #)-                                                                        GHC.Types.EQ ->-                                                                          (#-                                                                            farInp,-                                                                            failExp GHC.Base.<> farExp-                                                                          #)-                                                                        GHC.Types.GT ->-                                                                          (#-                                                                            farInp,-                                                                            farExp-                                                                          #)-                                                                 in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp farInp farExp-                                  else-                                    let _ = "choicesBranch.else"-                                     in finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp farInp farExp-                       in let _ = "catch ExceptionFailure"-                           in let catchHandler (!_exn) (!failInp) (!farInp) (!farExp) =-                                    let _ = "catch.ko ExceptionFailure"-                                     in catchHandler Symantic.Parser.Grammar.Combinators.ExceptionFailure init farInp farExp-                               in let readFail = catchHandler-                                   in if readMore (Symantic.Parser.Machine.Input.shiftRightText 1 init)-                                        then-                                          let !(# c, cs #) = readNext init-                                           in if (GHC.Classes.==) 'a' c-                                                then-                                                  let readFail = readFail-                                                   in let !(#-                                                             c,-                                                             cs-                                                             #) = readNext cs-                                                       in if (GHC.Classes.==) 'a' c-                                                            then-                                                              let _ = "resume"-                                                               in join-                                                                    init-                                                                    Data.Set.Internal.empty-                                                                    ( let _ = "resume.genCode"-                                                                       in (GHC.Types.:) 'a' ((GHC.Types.:) 'a' GHC.Types . [])-                                                                    )-                                                                    cs-                                                            else-                                                              let _ = "checkToken.else"-                                                               in let failExp =-                                                                        Data.Set.Internal.Bin-                                                                          1-                                                                          ( Symantic.Parser.Grammar.Combinators.SomeFailure-                                                                              ( case inputToken of-                                                                                  (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken 'a'-                                                                              )-                                                                          )-                                                                          Data.Set.Internal.Tip-                                                                          Data.Set.Internal.Tip-                                                                   in let (#-                                                                            farInp,-                                                                            farExp-                                                                            #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init cs of-                                                                              GHC.Types.LT ->-                                                                                (#-                                                                                  cs,-                                                                                  failExp-                                                                                #)-                                                                              GHC.Types.EQ ->-                                                                                (#-                                                                                  init,-                                                                                  failExp GHC.Base.<> Data.Set.Internal.empty-                                                                                #)-                                                                              GHC.Types.GT ->-                                                                                (#-                                                                                  init,-                                                                                  Data.Set.Internal.empty-                                                                                #)-                                                                       in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure cs farInp farExp-                                                else-                                                  let _ = "checkToken.else"-                                                   in let failExp =-                                                            Data.Set.Internal.Bin-                                                              1-                                                              ( Symantic.Parser.Grammar.Combinators.SomeFailure-                                                                  ( case inputToken of-                                                                      (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken 'a'-                                                                  )-                                                              )-                                                              Data.Set.Internal.Tip-                                                              Data.Set.Internal.Tip-                                                       in let (#-                                                                farInp,-                                                                farExp-                                                                #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init init of-                                                                  GHC.Types.LT ->-                                                                    (#-                                                                      init,-                                                                      failExp-                                                                    #)-                                                                  GHC.Types.EQ ->-                                                                    (#-                                                                      init,-                                                                      failExp GHC.Base.<> Data.Set.Internal.empty-                                                                    #)-                                                                  GHC.Types.GT ->-                                                                    (#-                                                                      init,-                                                                      Data.Set.Internal.empty-                                                                    #)-                                                           in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure init farInp farExp-                                        else-                                          let _ = "checkHorizon.else"-                                           in let failExp =-                                                    Data.Set.Internal.Bin-                                                      1-                                                      ( Symantic.Parser.Grammar.Combinators.SomeFailure-                                                          ( case inputToken of-                                                              (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureHorizon @tok' 2-                                                          )-                                                      )-                                                      Data.Set.Internal.Tip-                                                      Data.Set.Internal.Tip-                                               in let (#-                                                        farInp,-                                                        farExp-                                                        #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init init of-                                                          GHC.Types.LT ->-                                                            (#-                                                              init,-                                                              failExp-                                                            #)-                                                          GHC.Types.EQ ->-                                                            (#-                                                              init,-                                                              failExp GHC.Base.<> Data.Set.Internal.empty-                                                            #)-                                                          GHC.Types.GT ->-                                                            (#-                                                              init,-                                                              Data.Set.Internal.empty-                                                            #)-                                                   in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure init farInp farExp
− test/Golden/Splice/G8.expected.txt 
@@ -1,278 +0,0 @@-\(input :: inp) ->-  let !(#-         init,-         readMore,-         readNext-         #) =-          let _ = "cursorOf"-           in let next-                    ( t@( Data.Text.Internal.Text-                            arr-                            off-                            unconsumed-                          )-                      ) =-                      let !( Data.Text.Unsafe.Iter-                               c-                               d-                             ) = Data.Text.Unsafe.iter t 0-                       in (#-                            c,-                            Data.Text.Internal.Text arr (off GHC.Num.+ d) (unconsumed GHC.Num.- d)-                          #)-                  more-                    ( Data.Text.Internal.Text-                        _-                        _-                        unconsumed-                      ) = unconsumed GHC.Classes.> 0-               in (# input, more, next #)-      finalRet = \_farInp _farExp v _inp -> Data.Either.Right v-      finalRaise ::-        forall b.-        Symantic.Parser.Machine.Generate.Catcher-          inp-          b = \(!exn) _failInp (!farInp) (!farExp) ->-          Data.Either.Left-            Symantic.Parser.Machine.Generate.ParsingError-              { Symantic.Parser.Machine.Generate.parsingErrorOffset = Symantic.Parser.Machine.Input.offset farInp,-                Symantic.Parser.Machine.Generate.parsingErrorException = exn,-                Symantic.Parser.Machine.Generate.parsingErrorUnexpected =-                  if readMore farInp-                    then-                      GHC.Maybe.Just-                        ( let (#-                                c,-                                _-                                #) = readNext farInp-                           in c-                        )-                    else GHC.Maybe.Nothing,-                Symantic.Parser.Machine.Generate.parsingErrorExpecting = farExp-              }-   in let inputToken = Data.Proxy.Proxy :: Data.Proxy.Proxy (Symantic.Parser.Machine.Input.InputToken inp)-       in let name = \(!ok) (!inp) (!koByLabel) ->-                let _ = "catch ExceptionFailure"-                 in let catchHandler (!_exn) (!failInp) (!farInp) (!farExp) =-                          let _ = "catch.ko ExceptionFailure"-                           in if ( \( Data.Text.Internal.Text-                                        _-                                        i-                                        _-                                      )-                                    ( Data.Text.Internal.Text-                                        _-                                        j-                                        _-                                      ) -> i GHC.Classes.== j-                                 )-                                inp-                                failInp-                                then-                                  let _ = "choicesBranch.then"-                                   in let _ = "resume"-                                       in ok-                                            farInp-                                            farExp-                                            ( let _ = "resume.genCode"-                                               in \x -> x-                                            )-                                            failInp-                                else-                                  let _ = "choicesBranch.else"-                                   in Data.Map.Strict.Internal.findWithDefault finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure koByLabel Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp farInp farExp-                     in let readFail = catchHandler-                         in if readMore inp-                              then-                                let !(#-                                       c,-                                       cs-                                       #) = readNext inp-                                 in if (GHC.Classes.==) 'r' c-                                      then-                                        name-                                          ( let _ = "suspend"-                                             in \farInp farExp v (!inp) ->-                                                  let _ = "resume"-                                                   in ok-                                                        farInp-                                                        farExp-                                                        ( let _ = "resume.genCode"-                                                           in \x -> (GHC.Types.:) 'r' (v x)-                                                        )-                                                        inp-                                          )-                                          cs-                                          (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure readFail Data.Map.Internal.Tip Data.Map.Internal.Tip)-                                      else-                                        let _ = "checkToken.else"-                                         in let failExp =-                                                  Data.Set.Internal.Bin-                                                    1-                                                    ( Symantic.Parser.Grammar.Combinators.SomeFailure-                                                        ( case inputToken of-                                                            (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken 'r'-                                                        )-                                                    )-                                                    Data.Set.Internal.Tip-                                                    Data.Set.Internal.Tip-                                             in let (#-                                                      farInp,-                                                      farExp-                                                      #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init inp of-                                                        GHC.Types.LT ->-                                                          (#-                                                            inp,-                                                            failExp-                                                          #)-                                                        GHC.Types.EQ ->-                                                          (#-                                                            init,-                                                            failExp GHC.Base.<> Data.Set.Internal.empty-                                                          #)-                                                        GHC.Types.GT ->-                                                          (#-                                                            init,-                                                            Data.Set.Internal.empty-                                                          #)-                                                 in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp-                              else-                                let _ = "checkHorizon.else"-                                 in let failExp =-                                          Data.Set.Internal.Bin-                                            1-                                            ( Symantic.Parser.Grammar.Combinators.SomeFailure-                                                ( case inputToken of-                                                    (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureHorizon @tok' 1-                                                )-                                            )-                                            Data.Set.Internal.Tip-                                            Data.Set.Internal.Tip-                                     in let (#-                                              farInp,-                                              farExp-                                              #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init inp of-                                                GHC.Types.LT ->-                                                  (#-                                                    inp,-                                                    failExp-                                                  #)-                                                GHC.Types.EQ ->-                                                  (#-                                                    init,-                                                    failExp GHC.Base.<> Data.Set.Internal.empty-                                                  #)-                                                GHC.Types.GT ->-                                                  (#-                                                    init,-                                                    Data.Set.Internal.empty-                                                  #)-                                         in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp-           in name-                ( let _ = "suspend"-                   in \farInp farExp v (!inp) ->-                        let join = \farInp farExp v (!inp) ->-                              let _ = "resume"-                               in finalRet-                                    farInp-                                    farExp-                                    ( let _ = "resume.genCode"-                                       in GHC.Show.show (v GHC.Types . [])-                                    )-                                    inp-                         in let _ = "catch ExceptionFailure"-                             in let catchHandler (!_exn) (!failInp) (!farInp) (!farExp) =-                                      let _ = "catch.ko ExceptionFailure"-                                       in if ( \( Data.Text.Internal.Text-                                                    _-                                                    i-                                                    _-                                                  )-                                                ( Data.Text.Internal.Text-                                                    _-                                                    j-                                                    _-                                                  ) -> i GHC.Classes.== j-                                             )-                                            inp-                                            failInp-                                            then-                                              let _ = "choicesBranch.then"-                                               in let failExp = Data.Set.Internal.Bin 1 (Symantic.Parser.Grammar.Combinators.SomeFailure Symantic.Parser.Grammar.Combinators.FailureEnd) Data.Set.Internal.Tip Data.Set.Internal.Tip-                                                   in let (#-                                                            farInp,-                                                            farExp-                                                            #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp failInp of-                                                              GHC.Types.LT ->-                                                                (#-                                                                  failInp,-                                                                  failExp-                                                                #)-                                                              GHC.Types.EQ ->-                                                                (#-                                                                  farInp,-                                                                  failExp GHC.Base.<> farExp-                                                                #)-                                                              GHC.Types.GT ->-                                                                (#-                                                                  farInp,-                                                                  farExp-                                                                #)-                                                       in finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp farInp farExp-                                            else-                                              let _ = "choicesBranch.else"-                                               in finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp farInp farExp-                                 in let _ = "catch ExceptionFailure"-                                     in let catchHandler (!_exn) (!failInp) (!farInp) (!farExp) =-                                              let _ = "catch.ko ExceptionFailure"-                                               in let _ = "resume"-                                                   in join-                                                        farInp-                                                        farExp-                                                        ( let _ = "resume.genCode"-                                                           in GHC.Tuple . ()-                                                        )-                                                        inp-                                         in let readFail = catchHandler-                                             in if readMore inp-                                                  then-                                                    let !(#-                                                           c,-                                                           cs-                                                           #) = readNext inp-                                                     in catchHandler Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp-                                                  else-                                                    let _ = "checkHorizon.else"-                                                     in let failExp =-                                                              Data.Set.Internal.Bin-                                                                1-                                                                ( Symantic.Parser.Grammar.Combinators.SomeFailure-                                                                    ( case inputToken of-                                                                        (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureHorizon @tok' 1-                                                                    )-                                                                )-                                                                Data.Set.Internal.Tip-                                                                Data.Set.Internal.Tip-                                                         in let (#-                                                                  farInp,-                                                                  farExp-                                                                  #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp inp of-                                                                    GHC.Types.LT ->-                                                                      (#-                                                                        inp,-                                                                        failExp-                                                                      #)-                                                                    GHC.Types.EQ ->-                                                                      (#-                                                                        farInp,-                                                                        failExp GHC.Base.<> farExp-                                                                      #)-                                                                    GHC.Types.GT ->-                                                                      (#-                                                                        farInp,-                                                                        farExp-                                                                      #)-                                                             in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp-                )-                init-                Data.Map.Internal.Tip
− test/Golden/Splice/G9.expected.txt 
@@ -1,153 +0,0 @@-\(input :: inp) ->-  let !(#-         init,-         readMore,-         readNext-         #) =-          let _ = "cursorOf"-           in let next-                    ( t@( Data.Text.Internal.Text-                            arr-                            off-                            unconsumed-                          )-                      ) =-                      let !( Data.Text.Unsafe.Iter-                               c-                               d-                             ) = Data.Text.Unsafe.iter t 0-                       in (#-                            c,-                            Data.Text.Internal.Text arr (off GHC.Num.+ d) (unconsumed GHC.Num.- d)-                          #)-                  more-                    ( Data.Text.Internal.Text-                        _-                        _-                        unconsumed-                      ) = unconsumed GHC.Classes.> 0-               in (# input, more, next #)-      finalRet = \_farInp _farExp v _inp -> Data.Either.Right v-      finalRaise ::-        forall b.-        Symantic.Parser.Machine.Generate.Catcher-          inp-          b = \(!exn) _failInp (!farInp) (!farExp) ->-          Data.Either.Left-            Symantic.Parser.Machine.Generate.ParsingError-              { Symantic.Parser.Machine.Generate.parsingErrorOffset = Symantic.Parser.Machine.Input.offset farInp,-                Symantic.Parser.Machine.Generate.parsingErrorException = exn,-                Symantic.Parser.Machine.Generate.parsingErrorUnexpected =-                  if readMore farInp-                    then-                      GHC.Maybe.Just-                        ( let (#-                                c,-                                _-                                #) = readNext farInp-                           in c-                        )-                    else GHC.Maybe.Nothing,-                Symantic.Parser.Machine.Generate.parsingErrorExpecting = farExp-              }-   in let inputToken = Data.Proxy.Proxy :: Data.Proxy.Proxy (Symantic.Parser.Machine.Input.InputToken inp)-       in let-           in let join = \farInp farExp v (!inp) ->-                    let _ = "resume"-                     in finalRet-                          farInp-                          farExp-                          ( let _ = "resume.genCode"-                             in GHC.Show.show v-                          )-                          inp-               in let _ = "catch ExceptionFailure"-                   in let catchHandler (!_exn) (!failInp) (!farInp) (!farExp) =-                            let _ = "catch.ko ExceptionFailure"-                             in if ( \( Data.Text.Internal.Text-                                          _-                                          i-                                          _-                                        )-                                      ( Data.Text.Internal.Text-                                          _-                                          j-                                          _-                                        ) -> i GHC.Classes.== j-                                   )-                                  init-                                  failInp-                                  then-                                    let _ = "choicesBranch.then"-                                     in let failExp = Data.Set.Internal.Bin 1 (Symantic.Parser.Grammar.Combinators.SomeFailure Symantic.Parser.Grammar.Combinators.FailureEnd) Data.Set.Internal.Tip Data.Set.Internal.Tip-                                         in let (#-                                                  farInp,-                                                  farExp-                                                  #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp failInp of-                                                    GHC.Types.LT ->-                                                      (#-                                                        failInp,-                                                        failExp-                                                      #)-                                                    GHC.Types.EQ ->-                                                      (#-                                                        farInp,-                                                        failExp GHC.Base.<> farExp-                                                      #)-                                                    GHC.Types.GT ->-                                                      (#-                                                        farInp,-                                                        farExp-                                                      #)-                                             in finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp farInp farExp-                                  else-                                    let _ = "choicesBranch.else"-                                     in finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp farInp farExp-                       in let _ = "catch ExceptionFailure"-                           in let catchHandler (!_exn) (!failInp) (!farInp) (!farExp) =-                                    let _ = "catch.ko ExceptionFailure"-                                     in let _ = "resume"-                                         in join-                                              farInp-                                              farExp-                                              ( let _ = "resume.genCode"-                                                 in GHC.Tuple . ()-                                              )-                                              init-                               in let readFail = catchHandler-                                   in if readMore init-                                        then-                                          let !(# c, cs #) = readNext init-                                           in catchHandler Symantic.Parser.Grammar.Combinators.ExceptionFailure init init Data.Set.Internal.empty-                                        else-                                          let _ = "checkHorizon.else"-                                           in let failExp =-                                                    Data.Set.Internal.Bin-                                                      1-                                                      ( Symantic.Parser.Grammar.Combinators.SomeFailure-                                                          ( case inputToken of-                                                              (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureHorizon @tok' 1-                                                          )-                                                      )-                                                      Data.Set.Internal.Tip-                                                      Data.Set.Internal.Tip-                                               in let (#-                                                        farInp,-                                                        farExp-                                                        #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init init of-                                                          GHC.Types.LT ->-                                                            (#-                                                              init,-                                                              failExp-                                                            #)-                                                          GHC.Types.EQ ->-                                                            (#-                                                              init,-                                                              failExp GHC.Base.<> Data.Set.Internal.empty-                                                            #)-                                                          GHC.Types.GT ->-                                                            (#-                                                              init,-                                                              Data.Set.Internal.empty-                                                            #)-                                                   in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure init farInp farExp
− test/Golden/Utils.hs 
@@ -1,36 +0,0 @@-module Golden.Utils where--import Control.Monad (Monad(..))-import Data.Either (Either(..))-import Data.Function (($))-import Data.Semigroup (Semigroup(..))-import Data.String (String)-import System.IO (IO, FilePath)-import System.IO.Unsafe (unsafePerformIO)-import qualified Data.ByteString.Lazy as BSL-import qualified Data.IORef as IORef--import qualified Data.Text.Lazy as TL-import qualified Data.Text.Lazy.Encoding as TL-import qualified Language.Haskell.TH.Syntax as TH-import Paths_symantic_parser--getGoldenDir :: FilePath -> FilePath-getGoldenDir p = unsafePerformIO $ getDataFileName $ "test/Golden/" <> p--goldenDiff :: FilePath -> FilePath -> [String]-goldenDiff ref new = ["diff", "-u", "-w", "-B", ref, new]---- | Resetting 'TH.counter' makes 'makeLetName' deterministic,--- except when GHC or executable flags change, like profiling--- or even --accept unfortunately,--- in those case the 'goldensMachine' tests may fail--- due to a different numbering of the 'def' and 'ref' combinators.--- Hence 'ShowLetName' is used with 'False'.-resetTHNameCounter :: IO ()-resetTHNameCounter = IORef.writeIORef TH.counter 0--unLeft :: Either String BSL.ByteString -> IO BSL.ByteString-unLeft lr = case lr of-  Left err -> return $ TL.encodeUtf8 $ TL.pack err-  Right a  -> return a
− test/Grammar.hs 
@@ -1,54 +0,0 @@-{-# LANGUAGE FlexibleContexts #-}-{-# LANGUAGE NoMonomorphismRestriction #-}-{-# LANGUAGE TypeApplications #-}-{-# LANGUAGE TypeFamilies #-}-{-# LANGUAGE TemplateHaskell #-}-{-# OPTIONS_GHC -Wno-missing-signatures #-}-module Grammar where-import Data.Char (Char)-import Data.String (String)-import Text.Show (Show(..))-import qualified Data.Functor as Functor-import qualified Parsers.Nandlang-import qualified Parsers.Brainfuck.SymanticParser.Grammar--import Symantic.Parser--rawGrammars :: Grammarable Char repr => [repr String]-rawGrammars =-  [ production show [||show||] <$> g1-  , production show [||show||] <$> g2-  , production show [||show||] <$> g3-  , production show [||show||] <$> g4-  , production show [||show||] <$> g5-  , production show [||show||] <$> g6-  , production show [||show||] <$> g7-  , production show [||show||] <$> g8-  , production show [||show||] <$> g9-  , production show [||show||] <$> g10-  , production show [||show||] <$> g11-  , production show [||show||] <$> g12-  , production show [||show||] <$> g13-  , production show [||show||] <$> g14-  , production show [||show||] <$> g15-  , production show [||show||] <$> g16-  ]-grammars :: Grammarable Char repr => [repr String]-grammars = observeSharing Functor.<$> rawGrammars--g1 = char 'a'-g2 = string "abc"-g3 = many (char 'a')-g4 = some (string "abcd")-g5 = some (string "abcd") <* eof-g6 = traverse char "aa" <|> traverse char "ab"-g7 = string "aa" <|> string "ab"-g8 = many (char 'r') <* eof-g9 = eof-g10 = char 'a' <|> char 'b'-g11 = many (char 'a') <* char 'b'-g12 = many (oneOf ['a', 'b', 'c', 'd']) <* eof-g13 = Parsers.Brainfuck.SymanticParser.Grammar.grammar @Char @_-g14 = Parsers.Nandlang.grammar-g15 = (char 'a' <|> char 'b') <* char 'c'-g16 = (char 'a' <|> char 'b' <|> char 'c') <* char 'd'
− test/Main.hs 
@@ -1,15 +0,0 @@-module Main where--import System.IO (IO)-import Test.Tasty-import Golden---import HUnit--main :: IO ()-main = do-  defaultMain (-    testGroup ""-      [ Golden.goldens-      --, hunits-      ]-    )
+ tests/Golden.hs view
@@ -0,0 +1,16 @@+module Golden where++import Test.Tasty++import qualified Golden.Grammar+import qualified Golden.Machine+import qualified Golden.Parser+import qualified Golden.Splice++goldens :: TestTree+goldens = testGroup "Golden"+  [ Golden.Grammar.goldens+  , Golden.Machine.goldens+  , Golden.Parser.goldens+  , Golden.Splice.goldens+  ]
+ tests/Golden/Grammar.hs view
@@ -0,0 +1,38 @@+{-# LANGUAGE DataKinds #-} -- For using P.viewGrammar+{-# LANGUAGE Rank2Types #-}+{-# LANGUAGE TypeApplications #-}+module Golden.Grammar where++import Data.Bool (Bool(..))+import Control.Monad (Monad(..))+import Data.Function (($))+import Data.Semigroup (Semigroup(..))+import Data.String (IsString(..))+import Test.Tasty+import Test.Tasty.Golden+import Text.Show (Show(..))+import Data.Int (Int)+import qualified Data.List as List++import Golden.Utils+import qualified Symantic.Parser as P+import qualified Grammar++goldens :: TestTree+goldens = testGroup "Grammar" $+  [ testGroup "ViewGrammar" $+    (\f -> List.zipWith f Grammar.grammars [1::Int ..]) $ \g gNum ->+    let grammarFile = getGoldenDir $ "Grammar/ViewGrammar/G"<>show gNum<>".expected.txt" in+    goldenVsStringDiff ("G"<>show gNum) goldenDiff grammarFile $ do+      resetTHNameCounter+      return $ fromString $ show $+        P.viewGrammar @'False g+  , testGroup "OptimizeGrammar" $+    (\f -> List.zipWith f Grammar.grammars [1::Int ..]) $ \g gNum ->+    let grammarFile = getGoldenDir $ "Grammar/OptimizeGrammar/G"<>show gNum<>".expected.txt" in+    goldenVsStringDiff ("G"<>show gNum) goldenDiff grammarFile $ do+      resetTHNameCounter+      return $ fromString $ show $+        P.viewGrammar @'False $+        P.optimizeGrammar g+  ]
+ tests/Golden/Grammar/OptimizeGrammar/G1.expected.txt view
@@ -0,0 +1,4 @@+lets+` <*>+  + pure (\x_0 -> GHC.Show.show 'a')+  ` satisfy ((GHC.Classes.==) 'a')
+ tests/Golden/Grammar/OptimizeGrammar/G10.expected.txt view
@@ -0,0 +1,10 @@+lets+` <*>+  + pure GHC.Show.show+  ` <|>+    + <*>+    | + pure (\x_0 -> 'a')+    | ` satisfy ((GHC.Classes.==) 'a')+    ` <*>+      + pure (\x_0 -> 'b')+      ` satisfy ((GHC.Classes.==) 'b')
+ tests/Golden/Grammar/OptimizeGrammar/G11.expected.txt view
@@ -0,0 +1,10 @@+lets+` <*>+  + <*>+  | + pure (\x_0 -> \x_1 -> GHC.Show.show x_0)+  | ` chainPre+  |   + <*>+  |   | + pure (\x_0 -> (GHC.Types.:) 'a')+  |   | ` satisfy ((GHC.Classes.==) 'a')+  |   ` pure GHC.Types.[]+  ` satisfy ((GHC.Classes.==) 'b')
+ tests/Golden/Grammar/OptimizeGrammar/G12.expected.txt view
@@ -0,0 +1,10 @@+lets+` <*>+  + <*>+  | + pure (\x_0 -> \x_1 -> GHC.Show.show x_0)+  | ` chainPre+  |   + <*>+  |   | + pure (GHC.Types.:)+  |   | ` satisfy (\t_0 -> ('a' GHC.Classes.== t_0) GHC.Classes.|| (('b' GHC.Classes.== t_0) GHC.Classes.|| (('c' GHC.Classes.== t_0) GHC.Classes.|| (('d' GHC.Classes.== t_0) GHC.Classes.|| GHC.Types.False))))+  |   ` pure GHC.Types.[]+  ` eof
+ tests/Golden/Grammar/OptimizeGrammar/G13.expected.txt view
@@ -0,0 +1,61 @@+lets++ let name+| ` <*>+|   + pure (\x_0 -> GHC.Tuple.())+|   ` chainPost+|     + pure GHC.Tuple.()+|     ` <*>+|       + pure (\x_0 -> \x_1 -> x_1)+|       ` satisfy (\c_0 -> GHC.Classes.not (('<' GHC.Classes.== c_0) GHC.Classes.|| (('>' GHC.Classes.== c_0) GHC.Classes.|| (('+' GHC.Classes.== c_0) GHC.Classes.|| (('-' GHC.Classes.== c_0) GHC.Classes.|| ((',' GHC.Classes.== c_0) GHC.Classes.|| (('.' GHC.Classes.== c_0) GHC.Classes.|| (('[' GHC.Classes.== c_0) GHC.Classes.|| ((']' GHC.Classes.== c_0) GHC.Classes.|| GHC.Types.False)))))))))++ let name+| ` chainPre+|   + <*>+|   | + <*>+|   | | + pure (\x_0 -> \x_1 -> (GHC.Types.:) x_0)+|   | | ` conditional+|   | |   + condition+|   | |   | ` look+|   | |   |   ` satisfy (\x_0 -> GHC.Types.True)+|   | |   + default+|   | |   | ` failure+|   | |   + branch (\x_0 -> (\x_1 -> \x_2 -> (GHC.Classes.==) x_1 x_2) '<' x_0)+|   | |   | ` <*>+|   | |   |   + pure (\x_0 -> Parsers.Brainfuck.Types.Backward)+|   | |   |   ` satisfy (\x_0 -> GHC.Types.True)+|   | |   + branch (\x_0 -> (\x_1 -> \x_2 -> (GHC.Classes.==) x_1 x_2) '>' x_0)+|   | |   | ` <*>+|   | |   |   + pure (\x_0 -> Parsers.Brainfuck.Types.Forward)+|   | |   |   ` satisfy (\x_0 -> GHC.Types.True)+|   | |   + branch (\x_0 -> (\x_1 -> \x_2 -> (GHC.Classes.==) x_1 x_2) '+' x_0)+|   | |   | ` <*>+|   | |   |   + pure (\x_0 -> Parsers.Brainfuck.Types.Increment)+|   | |   |   ` satisfy (\x_0 -> GHC.Types.True)+|   | |   + branch (\x_0 -> (\x_1 -> \x_2 -> (GHC.Classes.==) x_1 x_2) '-' x_0)+|   | |   | ` <*>+|   | |   |   + pure (\x_0 -> Parsers.Brainfuck.Types.Decrement)+|   | |   |   ` satisfy (\x_0 -> GHC.Types.True)+|   | |   + branch (\x_0 -> (\x_1 -> \x_2 -> (GHC.Classes.==) x_1 x_2) ',' x_0)+|   | |   | ` <*>+|   | |   |   + pure (\x_0 -> Parsers.Brainfuck.Types.Input)+|   | |   |   ` satisfy (\x_0 -> GHC.Types.True)+|   | |   + branch (\x_0 -> (\x_1 -> \x_2 -> (GHC.Classes.==) x_1 x_2) '.' x_0)+|   | |   | ` <*>+|   | |   |   + pure (\x_0 -> Parsers.Brainfuck.Types.Output)+|   | |   |   ` satisfy (\x_0 -> GHC.Types.True)+|   | |   ` branch (\x_0 -> (\x_1 -> \x_2 -> (GHC.Classes.==) x_1 x_2) '[' x_0)+|   | |     ` <*>+|   | |       + <*>+|   | |       | + <*>+|   | |       | | + <*>+|   | |       | | | + pure (\x_0 -> \x_1 -> \x_2 -> \x_3 -> Parsers.Brainfuck.Types.Loop x_2)+|   | |       | | | ` satisfy (\x_0 -> GHC.Types.True)+|   | |       | | ` ref name+|   | |       | ` rec name+|   | |       ` satisfy ((GHC.Classes.==) ']')+|   | ` ref name+|   ` pure GHC.Types.[]+` <*>+  + <*>+  | + pure (\x_0 -> \x_1 -> GHC.Show.show x_1)+  | ` ref name+  ` ref name
+ tests/Golden/Grammar/OptimizeGrammar/G14.expected.txt view
@@ -0,0 +1,354 @@+lets++ let name+| ` <*>+|   + <*>+|   | + pure (\x_0 -> \x_1 -> x_1)+|   | ` ref name+|   ` <|>+|     + <*>+|     | + pure (\x_0 -> GHC.Tuple.())+|     | ` ref name+|     ` ref name++ let name+| ` <*>+|   + <*>+|   | + pure (\x_0 -> \x_1 -> GHC.Tuple.())+|   | ` ref name+|   ` chainPost+|     + pure GHC.Tuple.()+|     ` <*>+|       + pure (\x_0 -> \x_1 -> x_1)+|       ` ref name++ let name+| ` <*>+|   + <*>+|   | + <*>+|   | | + pure (\x_0 -> \x_1 -> \x_2 -> x_2)+|   | | ` ref name+|   | ` chainPost+|   |   + ref name+|   |   ` <*>+|   |     + <*>+|   |     | + <*>+|   |     | | + pure (\x_0 -> \x_1 -> \x_2 -> \x_3 -> x_3)+|   |     | | ` satisfy ((GHC.Classes.==) '!')+|   |     | ` ref name+|   |     ` ref name+|   ` ref name++ let name+| ` <*>+|   + <*>+|   | + <*>+|   | | + <*>+|   | | | + <*>+|   | | | | + <*>+|   | | | | | + pure (\x_0 -> \x_1 -> \x_2 -> \x_3 -> \x_4 -> \x_5 -> GHC.Tuple.())+|   | | | | | ` satisfy ((GHC.Classes.==) '[')+|   | | | | ` ref name+|   | | | ` ref name+|   | | ` chainPost+|   | |   + pure GHC.Tuple.()+|   | |   ` <*>+|   | |     + pure (\x_0 -> \x_1 -> x_1)+|   | |     ` ref name+|   | ` satisfy ((GHC.Classes.==) ']')+|   ` ref name++ let name+| ` <*>+|   + <*>+|   | + <*>+|   | | + <*>+|   | | | + <*>+|   | | | | + <*>+|   | | | | | + pure (\x_0 -> \x_1 -> \x_2 -> \x_3 -> \x_4 -> \x_5 -> x_3)+|   | | | | | ` satisfy ((GHC.Classes.==) '{')+|   | | | | ` ref name+|   | | | ` chainPost+|   | | |   + ref name+|   | | |   ` <*>+|   | | |     + pure (\x_0 -> \x_1 -> x_1)+|   | | |     ` <|>+|   | | |       + <*>+|   | | |       | + <*>+|   | | |       | | + pure (\x_0 -> \x_1 -> x_1)+|   | | |       | | ` try+|   | | |       | |   ` <*>+|   | | |       | |     + <*>+|   | | |       | |     | + pure (\x_0 -> \x_1 -> (GHC.Types.:) 'i' ((GHC.Types.:) 'f' GHC.Types.[]))+|   | | |       | |     | ` satisfy ((GHC.Classes.==) 'i')+|   | | |       | |     ` satisfy ((GHC.Classes.==) 'f')+|   | | |       | ` ref name+|   | | |       ` <|>+|   | | |         + <*>+|   | | |         | + <*>+|   | | |         | | + <*>+|   | | |         | | | + <*>+|   | | |         | | | | + pure (\x_0 -> \x_1 -> \x_2 -> \x_3 -> x_3)+|   | | |         | | | | ` try+|   | | |         | | | |   ` <*>+|   | | |         | | | |     + <*>+|   | | |         | | | |     | + <*>+|   | | |         | | | |     | | + <*>+|   | | |         | | | |     | | | + <*>+|   | | |         | | | |     | | | | + pure (\x_0 -> \x_1 -> \x_2 -> \x_3 -> \x_4 -> (GHC.Types.:) 'w' ((GHC.Types.:) 'h' ((GHC.Types.:) 'i' ((GHC.Types.:) 'l' ((GHC.Types.:) 'e' GHC.Types.[])))))+|   | | |         | | | |     | | | | ` satisfy ((GHC.Classes.==) 'w')+|   | | |         | | | |     | | | ` satisfy ((GHC.Classes.==) 'h')+|   | | |         | | | |     | | ` satisfy ((GHC.Classes.==) 'i')+|   | | |         | | | |     | ` satisfy ((GHC.Classes.==) 'l')+|   | | |         | | | |     ` satisfy ((GHC.Classes.==) 'e')+|   | | |         | | | ` ref name+|   | | |         | | ` ref name+|   | | |         | ` rec name+|   | | |         ` <|>+|   | | |           + try+|   | | |           | ` <*>+|   | | |           |   + <*>+|   | | |           |   | + <*>+|   | | |           |   | | + <*>+|   | | |           |   | | | + <*>+|   | | |           |   | | | | + <*>+|   | | |           |   | | | | | + <*>+|   | | |           |   | | | | | | + <*>+|   | | |           |   | | | | | | | + <*>+|   | | |           |   | | | | | | | | + <*>+|   | | |           |   | | | | | | | | | + pure (\x_0 -> \x_1 -> \x_2 -> \x_3 -> \x_4 -> \x_5 -> \x_6 -> \x_7 -> \x_8 -> \x_9 -> x_8)+|   | | |           |   | | | | | | | | | ` <|>+|   | | |           |   | | | | | | | | |   + <*>+|   | | |           |   | | | | | | | | |   | + <*>+|   | | |           |   | | | | | | | | |   | | + pure (\x_0 -> \x_1 -> GHC.Tuple.())+|   | | |           |   | | | | | | | | |   | | ` try+|   | | |           |   | | | | | | | | |   | |   ` <*>+|   | | |           |   | | | | | | | | |   | |     + <*>+|   | | |           |   | | | | | | | | |   | |     | + <*>+|   | | |           |   | | | | | | | | |   | |     | | + pure (\x_0 -> \x_1 -> \x_2 -> (GHC.Types.:) 'v' ((GHC.Types.:) 'a' ((GHC.Types.:) 'r' GHC.Types.[])))+|   | | |           |   | | | | | | | | |   | |     | | ` satisfy ((GHC.Classes.==) 'v')+|   | | |           |   | | | | | | | | |   | |     | ` satisfy ((GHC.Classes.==) 'a')+|   | | |           |   | | | | | | | | |   | |     ` satisfy ((GHC.Classes.==) 'r')+|   | | |           |   | | | | | | | | |   | ` ref name+|   | | |           |   | | | | | | | | |   ` ref name+|   | | |           |   | | | | | | | | ` ref name+|   | | |           |   | | | | | | | ` chainPost+|   | | |           |   | | | | | | |   + ref name+|   | | |           |   | | | | | | |   ` <*>+|   | | |           |   | | | | | | |     + <*>+|   | | |           |   | | | | | | |     | + <*>+|   | | |           |   | | | | | | |     | | + pure (\x_0 -> \x_1 -> \x_2 -> x_0 x_2)+|   | | |           |   | | | | | | |     | | ` ref name+|   | | |           |   | | | | | | |     | ` ref name+|   | | |           |   | | | | | | |     ` ref name+|   | | |           |   | | | | | | ` ref name+|   | | |           |   | | | | | ` satisfy ((GHC.Classes.==) '=')+|   | | |           |   | | | | ` ref name+|   | | |           |   | | | ` ref name+|   | | |           |   | | ` chainPost+|   | | |           |   | |   + ref name+|   | | |           |   | |   ` <*>+|   | | |           |   | |     + <*>+|   | | |           |   | |     | + <*>+|   | | |           |   | |     | | + pure (\x_0 -> \x_1 -> \x_2 -> x_0 x_2)+|   | | |           |   | |     | | ` ref name+|   | | |           |   | |     | ` ref name+|   | | |           |   | |     ` ref name+|   | | |           |   | ` ref name+|   | | |           |   ` ref name+|   | | |           ` <*>+|   | | |             + <*>+|   | | |             | + pure (\x_0 -> \x_1 -> x_0)+|   | | |             | ` ref name+|   | | |             ` ref name+|   | | ` ref name+|   | ` satisfy ((GHC.Classes.==) '}')+|   ` ref name++ let name+| ` <*>+|   + <*>+|   | + pure (\x_0 -> \x_1 -> '(')+|   | ` satisfy ((GHC.Classes.==) '(')+|   ` ref name++ let name+| ` <*>+|   + <*>+|   | + pure (\x_0 -> \x_1 -> ')')+|   | ` satisfy ((GHC.Classes.==) ')')+|   ` ref name++ let name+| ` <*>+|   + <*>+|   | + pure (\x_0 -> \x_1 -> ',')+|   | ` satisfy ((GHC.Classes.==) ',')+|   ` ref name++ let name+| ` <*>+|   + <*>+|   | + pure (\x_0 -> \x_1 -> ';')+|   | ` satisfy ((GHC.Classes.==) ';')+|   ` ref name++ let name+| ` <*>+|   + <*>+|   | + pure (\x_0 -> \x_1 -> x_1)+|   | ` satisfy GHC.Unicode.isSpace+|   ` ref name++ let name+| ` <*>+|   + <*>+|   | + pure (\x_0 -> \x_1 -> x_1)+|   | ` try+|   |   ` <*>+|   |     + <*>+|   |     | + <*>+|   |     | | + pure (\x_0 -> \x_1 -> \x_2 -> x_2)+|   |     | | ` satisfy Parsers.Nandlang.nandIdentStart+|   |     | ` chainPost+|   |     |   + ref name+|   |     |   ` <*>+|   |     |     + pure (\x_0 -> \x_1 -> x_1)+|   |     |     ` satisfy Parsers.Nandlang.nandIdentLetter+|   |     ` ref name+|   ` ref name++ let name+| ` <|>+|   + <*>+|   | + <*>+|   | | + pure (\x_0 -> \x_1 -> x_1)+|   | | ` <|>+|   | |   + <*>+|   | |   | + pure (\x_0 -> '0')+|   | |   | ` satisfy ((GHC.Classes.==) '0')+|   | |   ` <*>+|   | |     + pure (\x_0 -> '1')+|   | |     ` satisfy ((GHC.Classes.==) '1')+|   | ` ref name+|   ` <|>+|     + <*>+|     | + <*>+|     | | + <*>+|     | | | + <*>+|     | | | | + pure (\x_0 -> \x_1 -> \x_2 -> \x_3 -> x_1)+|     | | | | ` satisfy ((GHC.Classes.==) '\'')+|     | | | ` <|>+|     | | |   + <*>+|     | | |   | + <*>+|     | | |   | | + pure (\x_0 -> \x_1 -> x_1)+|     | | |   | | ` satisfy Parsers.Nandlang.nandStringLetter+|     | | |   | ` ref name+|     | | |   ` <*>+|     | | |     + <*>+|     | | |     | + <*>+|     | | |     | | + pure (\x_0 -> \x_1 -> \x_2 -> x_2)+|     | | |     | | ` satisfy ((GHC.Classes.==) '\\')+|     | | |     | ` satisfy (\t_0 -> ('0' GHC.Classes.== t_0) GHC.Classes.|| (('t' GHC.Classes.== t_0) GHC.Classes.|| (('n' GHC.Classes.== t_0) GHC.Classes.|| (('v' GHC.Classes.== t_0) GHC.Classes.|| (('f' GHC.Classes.== t_0) GHC.Classes.|| (('r' GHC.Classes.== t_0) GHC.Classes.|| GHC.Types.False))))))+|     | | |     ` ref name+|     | | ` satisfy ((GHC.Classes.==) '\'')+|     | ` ref name+|     ` <*>+|       + <*>+|       | + pure (\x_0 -> \x_1 -> x_1)+|       | ` ref name+|       ` <|>+|         + <*>+|         | + pure (\x_0 -> GHC.Tuple.())+|         | ` <|>+|         |   + <*>+|         |   | + <*>+|         |   | | + <*>+|         |   | | | + pure (\x_0 -> \x_1 -> \x_2 -> x_1)+|         |   | | | ` ref name+|         |   | | ` <|>+|         |   | |   + <*>+|         |   | |   | + <*>+|         |   | |   | | + <*>+|         |   | |   | | | + pure (\x_0 -> \x_1 -> \x_2 -> GHC.Tuple.())+|         |   | |   | | | ` rec name+|         |   | |   | | ` chainPost+|         |   | |   | |   + ref name+|         |   | |   | |   ` <*>+|         |   | |   | |     + <*>+|         |   | |   | |     | + <*>+|         |   | |   | |     | | + pure (\x_0 -> \x_1 -> \x_2 -> x_0 x_2)+|         |   | |   | |     | | ` ref name+|         |   | |   | |     | ` ref name+|         |   | |   | |     ` rec name+|         |   | |   | ` ref name+|         |   | |   ` ref name+|         |   | ` ref name+|         |   ` ref name+|         ` ref name++ let name+| ` <|>+|   + <*>+|   | + <*>+|   | | + <*>+|   | | | + pure (\x_0 -> \x_1 -> \x_2 -> GHC.Tuple.())+|   | | | ` ref name+|   | | ` chainPost+|   | |   + ref name+|   | |   ` <*>+|   | |     + <*>+|   | |     | + <*>+|   | |     | | + pure (\x_0 -> \x_1 -> \x_2 -> x_0 x_2)+|   | |     | | ` ref name+|   | |     | ` ref name+|   | |     ` ref name+|   | ` ref name+|   ` ref name++ let name+| ` pure (\x_0 -> \x_1 -> x_1)++ let name+| ` pure GHC.Tuple.()++ let name+| ` pure GHC.Tuple.()++ let name+| ` satisfy (\t_0 -> ('0' GHC.Classes.== t_0) GHC.Classes.|| (('1' GHC.Classes.== t_0) GHC.Classes.|| (('2' GHC.Classes.== t_0) GHC.Classes.|| (('3' GHC.Classes.== t_0) GHC.Classes.|| (('4' GHC.Classes.== t_0) GHC.Classes.|| (('5' GHC.Classes.== t_0) GHC.Classes.|| (('6' GHC.Classes.== t_0) GHC.Classes.|| (('7' GHC.Classes.== t_0) GHC.Classes.|| (('8' GHC.Classes.== t_0) GHC.Classes.|| (('9' GHC.Classes.== t_0) GHC.Classes.|| GHC.Types.False))))))))))+` <*>+  + <*>+  | + <*>+  | | + <*>+  | | | + pure (\x_0 -> \x_1 -> \x_2 -> \x_3 -> GHC.Show.show x_2)+  | | | ` ref name+  | | ` chainPost+  | |   + ref name+  | |   ` <*>+  | |     + <*>+  | |     | + <*>+  | |     | | + <*>+  | |     | | | + <*>+  | |     | | | | + <*>+  | |     | | | | | + <*>+  | |     | | | | | | + <*>+  | |     | | | | | | | + pure (\x_0 -> \x_1 -> \x_2 -> \x_3 -> \x_4 -> \x_5 -> \x_6 -> \x_7 -> \x_8 -> x_8)+  | |     | | | | | | | ` try+  | |     | | | | | | |   ` <*>+  | |     | | | | | | |     + <*>+  | |     | | | | | | |     | + <*>+  | |     | | | | | | |     | | + <*>+  | |     | | | | | | |     | | | + <*>+  | |     | | | | | | |     | | | | + <*>+  | |     | | | | | | |     | | | | | + <*>+  | |     | | | | | | |     | | | | | | + <*>+  | |     | | | | | | |     | | | | | | | + pure (\x_0 -> \x_1 -> \x_2 -> \x_3 -> \x_4 -> \x_5 -> \x_6 -> \x_7 -> (GHC.Types.:) 'f' ((GHC.Types.:) 'u' ((GHC.Types.:) 'n' ((GHC.Types.:) 'c' ((GHC.Types.:) 't' ((GHC.Types.:) 'i' ((GHC.Types.:) 'o' ((GHC.Types.:) 'n' GHC.Types.[]))))))))+  | |     | | | | | | |     | | | | | | | ` satisfy ((GHC.Classes.==) 'f')+  | |     | | | | | | |     | | | | | | ` satisfy ((GHC.Classes.==) 'u')+  | |     | | | | | | |     | | | | | ` satisfy ((GHC.Classes.==) 'n')+  | |     | | | | | | |     | | | | ` satisfy ((GHC.Classes.==) 'c')+  | |     | | | | | | |     | | | ` satisfy ((GHC.Classes.==) 't')+  | |     | | | | | | |     | | ` satisfy ((GHC.Classes.==) 'i')+  | |     | | | | | | |     | ` satisfy ((GHC.Classes.==) 'o')+  | |     | | | | | | |     ` satisfy ((GHC.Classes.==) 'n')+  | |     | | | | | | ` ref name+  | |     | | | | | ` ref name+  | |     | | | | ` ref name+  | |     | | | ` ref name+  | |     | | ` <|>+  | |     | |   + <*>+  | |     | |   | + <*>+  | |     | |   | | + <*>+  | |     | |   | | | + pure (\x_0 -> \x_1 -> \x_2 -> GHC.Tuple.())+  | |     | |   | | | ` satisfy ((GHC.Classes.==) ':')+  | |     | |   | | ` ref name+  | |     | |   | ` ref name+  | |     | |   ` ref name+  | |     | ` ref name+  | |     ` ref name+  | ` ref name+  ` eof
+ tests/Golden/Grammar/OptimizeGrammar/G15.expected.txt view
@@ -0,0 +1,12 @@+lets+` <*>+  + <*>+  | + pure (\x_0 -> \x_1 -> GHC.Show.show x_0)+  | ` <|>+  |   + <*>+  |   | + pure (\x_0 -> 'a')+  |   | ` satisfy ((GHC.Classes.==) 'a')+  |   ` <*>+  |     + pure (\x_0 -> 'b')+  |     ` satisfy ((GHC.Classes.==) 'b')+  ` satisfy ((GHC.Classes.==) 'c')
+ tests/Golden/Grammar/OptimizeGrammar/G16.expected.txt view
@@ -0,0 +1,16 @@+lets+` <*>+  + <*>+  | + pure (\x_0 -> \x_1 -> GHC.Show.show x_0)+  | ` <|>+  |   + <*>+  |   | + pure (\x_0 -> 'a')+  |   | ` satisfy ((GHC.Classes.==) 'a')+  |   ` <|>+  |     + <*>+  |     | + pure (\x_0 -> 'b')+  |     | ` satisfy ((GHC.Classes.==) 'b')+  |     ` <*>+  |       + pure (\x_0 -> 'c')+  |       ` satisfy ((GHC.Classes.==) 'c')+  ` satisfy ((GHC.Classes.==) 'd')
+ tests/Golden/Grammar/OptimizeGrammar/G17.expected.txt view
@@ -0,0 +1,10 @@+lets+` <*>+  + pure GHC.Show.show+  ` new reg_1+    + satisfy (\x_0 -> GHC.Types.True)+    ` <*>+      + <*>+      | + pure GHC.Tuple.(,)+      | ` get reg_1+      ` get reg_1
+ tests/Golden/Grammar/OptimizeGrammar/G18.expected.txt view
@@ -0,0 +1,18 @@+lets+` <*>+  + pure GHC.Show.show+  ` <|>+    + try+    | ` <*>+    |   + <*>+    |   | + <*>+    |   | | + pure (\x_0 -> \x_1 -> \x_2 -> (GHC.Types.:) 'a' ((GHC.Types.:) 'b' ((GHC.Types.:) 'c' GHC.Types.[])))+    |   | | ` satisfy ((GHC.Classes.==) 'a')+    |   | ` satisfy ((GHC.Classes.==) 'b')+    |   ` satisfy ((GHC.Classes.==) 'c')+    ` try+      ` <*>+        + <*>+        | + pure (\x_0 -> \x_1 -> (GHC.Types.:) 'd' ((GHC.Types.:) 'e' GHC.Types.[]))+        | ` satisfy ((GHC.Classes.==) 'd')+        ` satisfy ((GHC.Classes.==) 'e')
+ tests/Golden/Grammar/OptimizeGrammar/G19.expected.txt view
@@ -0,0 +1,29 @@+lets+` <*>+  + pure GHC.Show.show+  ` <|>+    + try+    | ` <*>+    |   + <*>+    |   | + <*>+    |   | | + pure (\x_0 -> \x_1 -> \x_2 -> (GHC.Types.:) 'a' ((GHC.Types.:) 'b' ((GHC.Types.:) 'c' GHC.Types.[])))+    |   | | ` satisfy ((GHC.Classes.==) 'a')+    |   | ` satisfy ((GHC.Classes.==) 'b')+    |   ` satisfy ((GHC.Classes.==) 'c')+    ` <|>+      + try+      | ` <*>+      |   + <*>+      |   | + pure (\x_0 -> \x_1 -> (GHC.Types.:) 'd' ((GHC.Types.:) 'e' GHC.Types.[]))+      |   | ` satisfy ((GHC.Classes.==) 'd')+      |   ` satisfy ((GHC.Classes.==) 'e')+      ` try+        ` <*>+          + <*>+          | + <*>+          | | + <*>+          | | | + pure (\x_0 -> \x_1 -> \x_2 -> \x_3 -> (GHC.Types.:) 'f' ((GHC.Types.:) 'g' ((GHC.Types.:) 'h' ((GHC.Types.:) 'i' GHC.Types.[]))))+          | | | ` satisfy ((GHC.Classes.==) 'f')+          | | ` satisfy ((GHC.Classes.==) 'g')+          | ` satisfy ((GHC.Classes.==) 'h')+          ` satisfy ((GHC.Classes.==) 'i')
+ tests/Golden/Grammar/OptimizeGrammar/G2.expected.txt view
@@ -0,0 +1,11 @@+lets+` <*>+  + pure GHC.Show.show+  ` try+    ` <*>+      + <*>+      | + <*>+      | | + pure (\x_0 -> \x_1 -> \x_2 -> (GHC.Types.:) 'a' ((GHC.Types.:) 'b' ((GHC.Types.:) 'c' GHC.Types.[])))+      | | ` satisfy ((GHC.Classes.==) 'a')+      | ` satisfy ((GHC.Classes.==) 'b')+      ` satisfy ((GHC.Classes.==) 'c')
+ tests/Golden/Grammar/OptimizeGrammar/G20.expected.txt view
@@ -0,0 +1,23 @@+lets+` <*>+  + <*>+  | + pure (\x_0 -> \x_1 -> GHC.Show.show GHC.Tuple.())+  | ` <|>+  |   + try+  |   | ` <*>+  |   |   + <*>+  |   |   | + <*>+  |   |   | | + pure (\x_0 -> \x_1 -> \x_2 -> (GHC.Types.:) 'a' ((GHC.Types.:) 'b' ((GHC.Types.:) 'c' GHC.Types.[])))+  |   |   | | ` satisfy ((GHC.Classes.==) 'a')+  |   |   | ` satisfy ((GHC.Classes.==) 'b')+  |   |   ` satisfy ((GHC.Classes.==) 'c')+  |   ` try+  |     ` pure GHC.Types.[]+  ` try+    ` <*>+      + <*>+      | + <*>+      | | + pure (\x_0 -> \x_1 -> \x_2 -> (GHC.Types.:) 'd' ((GHC.Types.:) 'e' ((GHC.Types.:) 'f' GHC.Types.[])))+      | | ` satisfy ((GHC.Classes.==) 'd')+      | ` satisfy ((GHC.Classes.==) 'e')+      ` satisfy ((GHC.Classes.==) 'f')
+ tests/Golden/Grammar/OptimizeGrammar/G3.expected.txt view
@@ -0,0 +1,8 @@+lets+` <*>+  + pure GHC.Show.show+  ` chainPre+    + <*>+    | + pure (\x_0 -> (GHC.Types.:) 'a')+    | ` satisfy ((GHC.Classes.==) 'a')+    ` pure GHC.Types.[]
+ tests/Golden/Grammar/OptimizeGrammar/G4.expected.txt view
@@ -0,0 +1,21 @@+lets++ let name+| ` try+|   ` <*>+|     + <*>+|     | + <*>+|     | | + <*>+|     | | | + pure (\x_0 -> \x_1 -> \x_2 -> \x_3 -> (GHC.Types.:) 'a' ((GHC.Types.:) 'b' ((GHC.Types.:) 'c' ((GHC.Types.:) 'd' GHC.Types.[]))))+|     | | | ` satisfy ((GHC.Classes.==) 'a')+|     | | ` satisfy ((GHC.Classes.==) 'b')+|     | ` satisfy ((GHC.Classes.==) 'c')+|     ` satisfy ((GHC.Classes.==) 'd')+` <*>+  + <*>+  | + pure (\x_0 -> \x_1 -> GHC.Show.show ((GHC.Types.:) x_0 x_1))+  | ` ref name+  ` chainPre+    + <*>+    | + pure (GHC.Types.:)+    | ` ref name+    ` pure GHC.Types.[]
+ tests/Golden/Grammar/OptimizeGrammar/G5.expected.txt view
@@ -0,0 +1,23 @@+lets++ let name+| ` try+|   ` <*>+|     + <*>+|     | + <*>+|     | | + <*>+|     | | | + pure (\x_0 -> \x_1 -> \x_2 -> \x_3 -> (GHC.Types.:) 'a' ((GHC.Types.:) 'b' ((GHC.Types.:) 'c' ((GHC.Types.:) 'd' GHC.Types.[]))))+|     | | | ` satisfy ((GHC.Classes.==) 'a')+|     | | ` satisfy ((GHC.Classes.==) 'b')+|     | ` satisfy ((GHC.Classes.==) 'c')+|     ` satisfy ((GHC.Classes.==) 'd')+` <*>+  + <*>+  | + <*>+  | | + pure (\x_0 -> \x_1 -> \x_2 -> GHC.Show.show ((GHC.Types.:) x_0 x_1))+  | | ` ref name+  | ` chainPre+  |   + <*>+  |   | + pure (GHC.Types.:)+  |   | ` ref name+  |   ` pure GHC.Types.[]+  ` eof
+ tests/Golden/Grammar/OptimizeGrammar/G6.expected.txt view
@@ -0,0 +1,14 @@+lets+` <*>+  + pure GHC.Show.show+  ` <|>+    + <*>+    | + <*>+    | | + pure (\x_0 -> \x_1 -> (GHC.Types.:) 'a' ((GHC.Types.:) 'a' GHC.Types.[]))+    | | ` satisfy ((GHC.Classes.==) 'a')+    | ` satisfy ((GHC.Classes.==) 'a')+    ` <*>+      + <*>+      | + pure (\x_0 -> \x_1 -> (GHC.Types.:) 'a' ((GHC.Types.:) 'b' GHC.Types.[]))+      | ` satisfy ((GHC.Classes.==) 'a')+      ` satisfy ((GHC.Classes.==) 'b')
+ tests/Golden/Grammar/OptimizeGrammar/G7.expected.txt view
@@ -0,0 +1,16 @@+lets+` <*>+  + pure GHC.Show.show+  ` <|>+    + try+    | ` <*>+    |   + <*>+    |   | + pure (\x_0 -> \x_1 -> (GHC.Types.:) 'a' ((GHC.Types.:) 'a' GHC.Types.[]))+    |   | ` satisfy ((GHC.Classes.==) 'a')+    |   ` satisfy ((GHC.Classes.==) 'a')+    ` try+      ` <*>+        + <*>+        | + pure (\x_0 -> \x_1 -> (GHC.Types.:) 'a' ((GHC.Types.:) 'b' GHC.Types.[]))+        | ` satisfy ((GHC.Classes.==) 'a')+        ` satisfy ((GHC.Classes.==) 'b')
+ tests/Golden/Grammar/OptimizeGrammar/G8.expected.txt view
@@ -0,0 +1,10 @@+lets+` <*>+  + <*>+  | + pure (\x_0 -> \x_1 -> GHC.Show.show x_0)+  | ` chainPre+  |   + <*>+  |   | + pure (\x_0 -> (GHC.Types.:) 'r')+  |   | ` satisfy ((GHC.Classes.==) 'r')+  |   ` pure GHC.Types.[]+  ` eof
+ tests/Golden/Grammar/OptimizeGrammar/G9.expected.txt view
@@ -0,0 +1,4 @@+lets+` <*>+  + pure GHC.Show.show+  ` eof
+ tests/Golden/Grammar/ViewGrammar/G1.expected.txt view
@@ -0,0 +1,8 @@+lets+` <*>+  + pure GHC.Show.show+  ` <*>+    + <*>+    | + pure (\x_0 -> \x_1 -> x_0)+    | ` pure 'a'+    ` satisfy ((GHC.Classes.==) 'a')
+ tests/Golden/Grammar/ViewGrammar/G10.expected.txt view
@@ -0,0 +1,14 @@+lets+` <*>+  + pure GHC.Show.show+  ` <|>+    + <*>+    | + <*>+    | | + pure (\x_0 -> \x_1 -> x_0)+    | | ` pure 'a'+    | ` satisfy ((GHC.Classes.==) 'a')+    ` <*>+      + <*>+      | + pure (\x_0 -> \x_1 -> x_0)+      | ` pure 'b'+      ` satisfy ((GHC.Classes.==) 'b')
+ tests/Golden/Grammar/ViewGrammar/G11.expected.txt view
@@ -0,0 +1,20 @@+lets+` <*>+  + pure GHC.Show.show+  ` <*>+    + <*>+    | + pure (\x_0 -> \x_1 -> x_0)+    | ` chainPre+    |   + <*>+    |   | + pure (GHC.Types.:)+    |   | ` <*>+    |   |   + <*>+    |   |   | + pure (\x_0 -> \x_1 -> x_0)+    |   |   | ` pure 'a'+    |   |   ` satisfy ((GHC.Classes.==) 'a')+    |   ` pure GHC.Types.[]+    ` <*>+      + <*>+      | + pure (\x_0 -> \x_1 -> x_0)+      | ` pure 'b'+      ` satisfy ((GHC.Classes.==) 'b')
+ tests/Golden/Grammar/ViewGrammar/G12.expected.txt view
@@ -0,0 +1,12 @@+lets+` <*>+  + pure GHC.Show.show+  ` <*>+    + <*>+    | + pure (\x_0 -> \x_1 -> x_0)+    | ` chainPre+    |   + <*>+    |   | + pure (GHC.Types.:)+    |   | ` satisfy (\t_0 -> ('a' GHC.Classes.== t_0) GHC.Classes.|| (('b' GHC.Classes.== t_0) GHC.Classes.|| (('c' GHC.Classes.== t_0) GHC.Classes.|| (('d' GHC.Classes.== t_0) GHC.Classes.|| GHC.Types.False))))+    |   ` pure GHC.Types.[]+    ` eof
+ tests/Golden/Grammar/ViewGrammar/G13.expected.txt view
@@ -0,0 +1,97 @@+lets++ let name+| ` <*>+|   + <*>+|   | + <*>+|   | | + pure (\x_0 -> \x_1 -> x_0)+|   | | ` pure (\x_0 -> x_0)+|   | ` chainPost+|   |   + pure GHC.Tuple.()+|   |   ` <*>+|   |     + <*>+|   |     | + pure (\x_0 -> \x_1 -> \x_2 -> x_0 x_2 x_1)+|   |     | ` pure (\x_0 -> \x_1 -> x_0)+|   |     ` satisfy (\c_0 -> GHC.Classes.not (('<' GHC.Classes.== c_0) GHC.Classes.|| (('>' GHC.Classes.== c_0) GHC.Classes.|| (('+' GHC.Classes.== c_0) GHC.Classes.|| (('-' GHC.Classes.== c_0) GHC.Classes.|| ((',' GHC.Classes.== c_0) GHC.Classes.|| (('.' GHC.Classes.== c_0) GHC.Classes.|| (('[' GHC.Classes.== c_0) GHC.Classes.|| ((']' GHC.Classes.== c_0) GHC.Classes.|| GHC.Types.False)))))))))+|   ` pure GHC.Tuple.()++ let name+| ` chainPre+|   + <*>+|   | + pure (GHC.Types.:)+|   | ` <*>+|   |   + <*>+|   |   | + pure (\x_0 -> \x_1 -> x_0)+|   |   | ` conditional+|   |   |   + condition+|   |   |   | ` look+|   |   |   |   ` satisfy (\x_0 -> GHC.Types.True)+|   |   |   + default+|   |   |   | ` failure+|   |   |   + branch (\x_0 -> (\x_1 -> \x_2 -> (GHC.Classes.==) x_1 x_2) '<' x_0)+|   |   |   | ` <*>+|   |   |   |   + <*>+|   |   |   |   | + pure (\x_0 -> \x_1 -> x_0)+|   |   |   |   | ` pure Parsers.Brainfuck.Types.Backward+|   |   |   |   ` satisfy (\x_0 -> GHC.Types.True)+|   |   |   + branch (\x_0 -> (\x_1 -> \x_2 -> (GHC.Classes.==) x_1 x_2) '>' x_0)+|   |   |   | ` <*>+|   |   |   |   + <*>+|   |   |   |   | + pure (\x_0 -> \x_1 -> x_0)+|   |   |   |   | ` pure Parsers.Brainfuck.Types.Forward+|   |   |   |   ` satisfy (\x_0 -> GHC.Types.True)+|   |   |   + branch (\x_0 -> (\x_1 -> \x_2 -> (GHC.Classes.==) x_1 x_2) '+' x_0)+|   |   |   | ` <*>+|   |   |   |   + <*>+|   |   |   |   | + pure (\x_0 -> \x_1 -> x_0)+|   |   |   |   | ` pure Parsers.Brainfuck.Types.Increment+|   |   |   |   ` satisfy (\x_0 -> GHC.Types.True)+|   |   |   + branch (\x_0 -> (\x_1 -> \x_2 -> (GHC.Classes.==) x_1 x_2) '-' x_0)+|   |   |   | ` <*>+|   |   |   |   + <*>+|   |   |   |   | + pure (\x_0 -> \x_1 -> x_0)+|   |   |   |   | ` pure Parsers.Brainfuck.Types.Decrement+|   |   |   |   ` satisfy (\x_0 -> GHC.Types.True)+|   |   |   + branch (\x_0 -> (\x_1 -> \x_2 -> (GHC.Classes.==) x_1 x_2) ',' x_0)+|   |   |   | ` <*>+|   |   |   |   + <*>+|   |   |   |   | + pure (\x_0 -> \x_1 -> x_0)+|   |   |   |   | ` pure Parsers.Brainfuck.Types.Input+|   |   |   |   ` satisfy (\x_0 -> GHC.Types.True)+|   |   |   + branch (\x_0 -> (\x_1 -> \x_2 -> (GHC.Classes.==) x_1 x_2) '.' x_0)+|   |   |   | ` <*>+|   |   |   |   + <*>+|   |   |   |   | + pure (\x_0 -> \x_1 -> x_0)+|   |   |   |   | ` pure Parsers.Brainfuck.Types.Output+|   |   |   |   ` satisfy (\x_0 -> GHC.Types.True)+|   |   |   ` branch (\x_0 -> (\x_1 -> \x_2 -> (GHC.Classes.==) x_1 x_2) '[' x_0)+|   |   |     ` <*>+|   |   |       + <*>+|   |   |       | + pure (\x_0 -> \x_1 -> x_0)+|   |   |       | ` <*>+|   |   |       |   + <*>+|   |   |       |   | + <*>+|   |   |       |   | | + pure (\x_0 -> \x_1 -> x_0)+|   |   |       |   | | ` pure (\x_0 -> x_0)+|   |   |       |   | ` <*>+|   |   |       |   |   + <*>+|   |   |       |   |   | + pure (\x_0 -> \x_1 -> x_0)+|   |   |       |   |   | ` satisfy (\x_0 -> GHC.Types.True)+|   |   |       |   |   ` ref name+|   |   |       |   ` <*>+|   |   |       |     + pure Parsers.Brainfuck.Types.Loop+|   |   |       |     ` rec name+|   |   |       ` <*>+|   |   |         + <*>+|   |   |         | + pure (\x_0 -> \x_1 -> x_0)+|   |   |         | ` pure ']'+|   |   |         ` satisfy ((GHC.Classes.==) ']')+|   |   ` ref name+|   ` pure GHC.Types.[]+` <*>+  + pure GHC.Show.show+  ` <*>+    + <*>+    | + <*>+    | | + pure (\x_0 -> \x_1 -> x_0)+    | | ` pure (\x_0 -> x_0)+    | ` ref name+    ` ref name
+ tests/Golden/Grammar/ViewGrammar/G14.expected.txt view
@@ -0,0 +1,744 @@+lets++ let name+| ` <*>+|   + <*>+|   | + <*>+|   | | + pure (\x_0 -> \x_1 -> x_0)+|   | | ` pure (\x_0 -> x_0)+|   | ` ref name+|   ` <*>+|     + <*>+|     | + <*>+|     | | + pure (\x_0 -> \x_1 -> x_0)+|     | | ` pure (\x_0 -> x_0)+|     | ` chainPost+|     |   + pure GHC.Tuple.()+|     |   ` <*>+|     |     + <*>+|     |     | + pure (\x_0 -> \x_1 -> \x_2 -> x_0 x_2 x_1)+|     |     | ` pure (\x_0 -> \x_1 -> x_0)+|     |     ` ref name+|     ` pure GHC.Tuple.()++ let name+| ` <*>+|   + <*>+|   | + <*>+|   | | + pure (\x_0 -> \x_1 -> x_0)+|   | | ` pure (\x_0 -> x_0)+|   | ` ref name+|   ` <*>+|     + <*>+|     | + <*>+|     | | + pure (\x_0 -> \x_1 -> x_0)+|     | | ` pure (\x_0 -> x_0)+|     | ` chainPost+|     |   + ref name+|     |   ` <*>+|     |     + <*>+|     |     | + pure (\x_0 -> \x_1 -> \x_2 -> x_0 x_2 x_1)+|     |     | ` pure (\x_0 -> \x_1 -> x_0)+|     |     ` <*>+|     |       + <*>+|     |       | + <*>+|     |       | | + pure (\x_0 -> \x_1 -> x_0)+|     |       | | ` pure (\x_0 -> x_0)+|     |       | ` <*>+|     |       |   + <*>+|     |       |   | + pure (\x_0 -> \x_1 -> x_0)+|     |       |   | ` <*>+|     |       |   |   + <*>+|     |       |   |   | + pure (\x_0 -> \x_1 -> x_0)+|     |       |   |   | ` pure '!'+|     |       |   |   ` satisfy ((GHC.Classes.==) '!')+|     |       |   ` ref name+|     |       ` ref name+|     ` ref name++ let name+| ` <*>+|   + <*>+|   | + pure (\x_0 -> \x_1 -> x_0)+|   | ` <*>+|   |   + <*>+|   |   | + <*>+|   |   | | + pure (\x_0 -> \x_1 -> x_0)+|   |   | | ` pure (\x_0 -> x_0)+|   |   | ` <*>+|   |   |   + <*>+|   |   |   | + pure (\x_0 -> \x_1 -> x_0)+|   |   |   | ` <*>+|   |   |   |   + <*>+|   |   |   |   | + pure (\x_0 -> \x_1 -> x_0)+|   |   |   |   | ` pure '['+|   |   |   |   ` satisfy ((GHC.Classes.==) '[')+|   |   |   ` ref name+|   |   ` <*>+|   |     + <*>+|   |     | + <*>+|   |     | | + pure (\x_0 -> \x_1 -> x_0)+|   |     | | ` pure (\x_0 -> x_0)+|   |     | ` ref name+|   |     ` <*>+|   |       + <*>+|   |       | + <*>+|   |       | | + pure (\x_0 -> \x_1 -> x_0)+|   |       | | ` pure (\x_0 -> x_0)+|   |       | ` chainPost+|   |       |   + pure GHC.Tuple.()+|   |       |   ` <*>+|   |       |     + <*>+|   |       |     | + pure (\x_0 -> \x_1 -> \x_2 -> x_0 x_2 x_1)+|   |       |     | ` pure (\x_0 -> \x_1 -> x_0)+|   |       |     ` ref name+|   |       ` pure GHC.Tuple.()+|   ` <*>+|     + <*>+|     | + pure (\x_0 -> \x_1 -> x_0)+|     | ` <*>+|     |   + <*>+|     |   | + pure (\x_0 -> \x_1 -> x_0)+|     |   | ` pure ']'+|     |   ` satisfy ((GHC.Classes.==) ']')+|     ` ref name++ let name+| ` <*>+|   + <*>+|   | + pure (\x_0 -> \x_1 -> x_0)+|   | ` <*>+|   |   + <*>+|   |   | + <*>+|   |   | | + pure (\x_0 -> \x_1 -> x_0)+|   |   | | ` pure (\x_0 -> x_0)+|   |   | ` <*>+|   |   |   + <*>+|   |   |   | + pure (\x_0 -> \x_1 -> x_0)+|   |   |   | ` <*>+|   |   |   |   + <*>+|   |   |   |   | + pure (\x_0 -> \x_1 -> x_0)+|   |   |   |   | ` pure '{'+|   |   |   |   ` satisfy ((GHC.Classes.==) '{')+|   |   |   ` ref name+|   |   ` <*>+|   |     + <*>+|   |     | + <*>+|   |     | | + pure (\x_0 -> \x_1 -> x_0)+|   |     | | ` pure (\x_0 -> x_0)+|   |     | ` chainPost+|   |     |   + ref name+|   |     |   ` <*>+|   |     |     + <*>+|   |     |     | + pure (\x_0 -> \x_1 -> \x_2 -> x_0 x_2 x_1)+|   |     |     | ` pure (\x_0 -> \x_1 -> x_0)+|   |     |     ` <|>+|   |     |       + <|>+|   |     |       | + <|>+|   |     |       | | + <*>+|   |     |       | | | + <*>+|   |     |       | | | | + <*>+|   |     |       | | | | | + pure (\x_0 -> \x_1 -> x_0)+|   |     |       | | | | | ` pure (\x_0 -> x_0)+|   |     |       | | | | ` try+|   |     |       | | | |   ` <*>+|   |     |       | | | |     + <*>+|   |     |       | | | |     | + pure (GHC.Types.:)+|   |     |       | | | |     | ` <*>+|   |     |       | | | |     |   + <*>+|   |     |       | | | |     |   | + pure (\x_0 -> \x_1 -> x_0)+|   |     |       | | | |     |   | ` pure 'i'+|   |     |       | | | |     |   ` satisfy ((GHC.Classes.==) 'i')+|   |     |       | | | |     ` <*>+|   |     |       | | | |       + <*>+|   |     |       | | | |       | + pure (GHC.Types.:)+|   |     |       | | | |       | ` <*>+|   |     |       | | | |       |   + <*>+|   |     |       | | | |       |   | + pure (\x_0 -> \x_1 -> x_0)+|   |     |       | | | |       |   | ` pure 'f'+|   |     |       | | | |       |   ` satisfy ((GHC.Classes.==) 'f')+|   |     |       | | | |       ` pure GHC.Types.[]+|   |     |       | | | ` ref name+|   |     |       | | ` <*>+|   |     |       | |   + <*>+|   |     |       | |   | + <*>+|   |     |       | |   | | + pure (\x_0 -> \x_1 -> x_0)+|   |     |       | |   | | ` pure (\x_0 -> x_0)+|   |     |       | |   | ` <*>+|   |     |       | |   |   + <*>+|   |     |       | |   |   | + <*>+|   |     |       | |   |   | | + pure (\x_0 -> \x_1 -> x_0)+|   |     |       | |   |   | | ` pure (\x_0 -> x_0)+|   |     |       | |   |   | ` <*>+|   |     |       | |   |   |   + <*>+|   |     |       | |   |   |   | + <*>+|   |     |       | |   |   |   | | + pure (\x_0 -> \x_1 -> x_0)+|   |     |       | |   |   |   | | ` pure (\x_0 -> x_0)+|   |     |       | |   |   |   | ` try+|   |     |       | |   |   |   |   ` <*>+|   |     |       | |   |   |   |     + <*>+|   |     |       | |   |   |   |     | + pure (GHC.Types.:)+|   |     |       | |   |   |   |     | ` <*>+|   |     |       | |   |   |   |     |   + <*>+|   |     |       | |   |   |   |     |   | + pure (\x_0 -> \x_1 -> x_0)+|   |     |       | |   |   |   |     |   | ` pure 'w'+|   |     |       | |   |   |   |     |   ` satisfy ((GHC.Classes.==) 'w')+|   |     |       | |   |   |   |     ` <*>+|   |     |       | |   |   |   |       + <*>+|   |     |       | |   |   |   |       | + pure (GHC.Types.:)+|   |     |       | |   |   |   |       | ` <*>+|   |     |       | |   |   |   |       |   + <*>+|   |     |       | |   |   |   |       |   | + pure (\x_0 -> \x_1 -> x_0)+|   |     |       | |   |   |   |       |   | ` pure 'h'+|   |     |       | |   |   |   |       |   ` satisfy ((GHC.Classes.==) 'h')+|   |     |       | |   |   |   |       ` <*>+|   |     |       | |   |   |   |         + <*>+|   |     |       | |   |   |   |         | + pure (GHC.Types.:)+|   |     |       | |   |   |   |         | ` <*>+|   |     |       | |   |   |   |         |   + <*>+|   |     |       | |   |   |   |         |   | + pure (\x_0 -> \x_1 -> x_0)+|   |     |       | |   |   |   |         |   | ` pure 'i'+|   |     |       | |   |   |   |         |   ` satisfy ((GHC.Classes.==) 'i')+|   |     |       | |   |   |   |         ` <*>+|   |     |       | |   |   |   |           + <*>+|   |     |       | |   |   |   |           | + pure (GHC.Types.:)+|   |     |       | |   |   |   |           | ` <*>+|   |     |       | |   |   |   |           |   + <*>+|   |     |       | |   |   |   |           |   | + pure (\x_0 -> \x_1 -> x_0)+|   |     |       | |   |   |   |           |   | ` pure 'l'+|   |     |       | |   |   |   |           |   ` satisfy ((GHC.Classes.==) 'l')+|   |     |       | |   |   |   |           ` <*>+|   |     |       | |   |   |   |             + <*>+|   |     |       | |   |   |   |             | + pure (GHC.Types.:)+|   |     |       | |   |   |   |             | ` <*>+|   |     |       | |   |   |   |             |   + <*>+|   |     |       | |   |   |   |             |   | + pure (\x_0 -> \x_1 -> x_0)+|   |     |       | |   |   |   |             |   | ` pure 'e'+|   |     |       | |   |   |   |             |   ` satisfy ((GHC.Classes.==) 'e')+|   |     |       | |   |   |   |             ` pure GHC.Types.[]+|   |     |       | |   |   |   ` ref name+|   |     |       | |   |   ` ref name+|   |     |       | |   ` rec name+|   |     |       | ` try+|   |     |       |   ` <*>+|   |     |       |     + <*>+|   |     |       |     | + pure (\x_0 -> \x_1 -> x_0)+|   |     |       |     | ` <*>+|   |     |       |     |   + <*>+|   |     |       |     |   | + <*>+|   |     |       |     |   | | + pure (\x_0 -> \x_1 -> x_0)+|   |     |       |     |   | | ` pure (\x_0 -> x_0)+|   |     |       |     |   | ` <*>+|   |     |       |     |   |   + <*>+|   |     |       |     |   |   | + <*>+|   |     |       |     |   |   | | + pure (\x_0 -> \x_1 -> x_0)+|   |     |       |     |   |   | | ` pure (\x_0 -> x_0)+|   |     |       |     |   |   | ` <*>+|   |     |       |     |   |   |   + <*>+|   |     |       |     |   |   |   | + <*>+|   |     |       |     |   |   |   | | + pure (\x_0 -> \x_1 -> x_0)+|   |     |       |     |   |   |   | | ` pure (\x_0 -> x_0)+|   |     |       |     |   |   |   | ` <|>+|   |     |       |     |   |   |   |   + <*>+|   |     |       |     |   |   |   |   | + <*>+|   |     |       |     |   |   |   |   | | + pure (\x_0 -> \x_1 -> x_0)+|   |     |       |     |   |   |   |   | | ` pure GHC.Tuple.()+|   |     |       |     |   |   |   |   | ` <*>+|   |     |       |     |   |   |   |   |   + <*>+|   |     |       |     |   |   |   |   |   | + <*>+|   |     |       |     |   |   |   |   |   | | + pure (\x_0 -> \x_1 -> x_0)+|   |     |       |     |   |   |   |   |   | | ` pure (\x_0 -> x_0)+|   |     |       |     |   |   |   |   |   | ` try+|   |     |       |     |   |   |   |   |   |   ` <*>+|   |     |       |     |   |   |   |   |   |     + <*>+|   |     |       |     |   |   |   |   |   |     | + pure (GHC.Types.:)+|   |     |       |     |   |   |   |   |   |     | ` <*>+|   |     |       |     |   |   |   |   |   |     |   + <*>+|   |     |       |     |   |   |   |   |   |     |   | + pure (\x_0 -> \x_1 -> x_0)+|   |     |       |     |   |   |   |   |   |     |   | ` pure 'v'+|   |     |       |     |   |   |   |   |   |     |   ` satisfy ((GHC.Classes.==) 'v')+|   |     |       |     |   |   |   |   |   |     ` <*>+|   |     |       |     |   |   |   |   |   |       + <*>+|   |     |       |     |   |   |   |   |   |       | + pure (GHC.Types.:)+|   |     |       |     |   |   |   |   |   |       | ` <*>+|   |     |       |     |   |   |   |   |   |       |   + <*>+|   |     |       |     |   |   |   |   |   |       |   | + pure (\x_0 -> \x_1 -> x_0)+|   |     |       |     |   |   |   |   |   |       |   | ` pure 'a'+|   |     |       |     |   |   |   |   |   |       |   ` satisfy ((GHC.Classes.==) 'a')+|   |     |       |     |   |   |   |   |   |       ` <*>+|   |     |       |     |   |   |   |   |   |         + <*>+|   |     |       |     |   |   |   |   |   |         | + pure (GHC.Types.:)+|   |     |       |     |   |   |   |   |   |         | ` <*>+|   |     |       |     |   |   |   |   |   |         |   + <*>+|   |     |       |     |   |   |   |   |   |         |   | + pure (\x_0 -> \x_1 -> x_0)+|   |     |       |     |   |   |   |   |   |         |   | ` pure 'r'+|   |     |       |     |   |   |   |   |   |         |   ` satisfy ((GHC.Classes.==) 'r')+|   |     |       |     |   |   |   |   |   |         ` pure GHC.Types.[]+|   |     |       |     |   |   |   |   |   ` ref name+|   |     |       |     |   |   |   |   ` ref name+|   |     |       |     |   |   |   ` <*>+|   |     |       |     |   |   |     + <*>+|   |     |       |     |   |   |     | + <*>+|   |     |       |     |   |   |     | | + pure (\x_0 -> \x_1 -> x_0)+|   |     |       |     |   |   |     | | ` pure (\x_0 -> x_0)+|   |     |       |     |   |   |     | ` ref name+|   |     |       |     |   |   |     ` <*>+|   |     |       |     |   |   |       + <*>+|   |     |       |     |   |   |       | + <*>+|   |     |       |     |   |   |       | | + pure (\x_0 -> \x_1 -> x_0)+|   |     |       |     |   |   |       | | ` pure (\x_0 -> x_0)+|   |     |       |     |   |   |       | ` chainPost+|   |     |       |     |   |   |       |   + ref name+|   |     |       |     |   |   |       |   ` <*>+|   |     |       |     |   |   |       |     + ref name+|   |     |       |     |   |   |       |     ` <*>+|   |     |       |     |   |   |       |       + <*>+|   |     |       |     |   |   |       |       | + <*>+|   |     |       |     |   |   |       |       | | + pure (\x_0 -> \x_1 -> x_0)+|   |     |       |     |   |   |       |       | | ` pure (\x_0 -> x_0)+|   |     |       |     |   |   |       |       | ` ref name+|   |     |       |     |   |   |       |       ` ref name+|   |     |       |     |   |   |       ` ref name+|   |     |       |     |   |   ` <*>+|   |     |       |     |   |     + <*>+|   |     |       |     |   |     | + pure (\x_0 -> \x_1 -> x_0)+|   |     |       |     |   |     | ` <*>+|   |     |       |     |   |     |   + <*>+|   |     |       |     |   |     |   | + pure (\x_0 -> \x_1 -> x_0)+|   |     |       |     |   |     |   | ` pure '='+|   |     |       |     |   |     |   ` satisfy ((GHC.Classes.==) '=')+|   |     |       |     |   |     ` ref name+|   |     |       |     |   ` <*>+|   |     |       |     |     + <*>+|   |     |       |     |     | + <*>+|   |     |       |     |     | | + pure (\x_0 -> \x_1 -> x_0)+|   |     |       |     |     | | ` pure (\x_0 -> x_0)+|   |     |       |     |     | ` ref name+|   |     |       |     |     ` <*>+|   |     |       |     |       + <*>+|   |     |       |     |       | + <*>+|   |     |       |     |       | | + pure (\x_0 -> \x_1 -> x_0)+|   |     |       |     |       | | ` pure (\x_0 -> x_0)+|   |     |       |     |       | ` chainPost+|   |     |       |     |       |   + ref name+|   |     |       |     |       |   ` <*>+|   |     |       |     |       |     + ref name+|   |     |       |     |       |     ` <*>+|   |     |       |     |       |       + <*>+|   |     |       |     |       |       | + <*>+|   |     |       |     |       |       | | + pure (\x_0 -> \x_1 -> x_0)+|   |     |       |     |       |       | | ` pure (\x_0 -> x_0)+|   |     |       |     |       |       | ` ref name+|   |     |       |     |       |       ` ref name+|   |     |       |     |       ` ref name+|   |     |       |     ` ref name+|   |     |       ` <*>+|   |     |         + <*>+|   |     |         | + pure (\x_0 -> \x_1 -> x_0)+|   |     |         | ` ref name+|   |     |         ` ref name+|   |     ` ref name+|   ` <*>+|     + <*>+|     | + pure (\x_0 -> \x_1 -> x_0)+|     | ` <*>+|     |   + <*>+|     |   | + pure (\x_0 -> \x_1 -> x_0)+|     |   | ` pure '}'+|     |   ` satisfy ((GHC.Classes.==) '}')+|     ` ref name++ let name+| ` <*>+|   + <*>+|   | + <*>+|   | | + pure (\x_0 -> \x_1 -> x_0)+|   | | ` pure (\x_0 -> x_0)+|   | ` ref name+|   ` <|>+|     + <*>+|     | + <*>+|     | | + pure (\x_0 -> \x_1 -> x_0)+|     | | ` pure GHC.Tuple.()+|     | ` ref name+|     ` ref name++ let name+| ` <*>+|   + <*>+|   | + <*>+|   | | + pure (\x_0 -> \x_1 -> x_0)+|   | | ` pure (\x_0 -> x_0)+|   | ` satisfy GHC.Unicode.isSpace+|   ` ref name++ let name+| ` <*>+|   + <*>+|   | + <*>+|   | | + pure (\x_0 -> \x_1 -> x_0)+|   | | ` pure (\x_0 -> x_0)+|   | ` try+|   |   ` <*>+|   |     + <*>+|   |     | + <*>+|   |     | | + pure (\x_0 -> \x_1 -> x_0)+|   |     | | ` pure (\x_0 -> x_0)+|   |     | ` satisfy Parsers.Nandlang.nandIdentStart+|   |     ` <*>+|   |       + <*>+|   |       | + <*>+|   |       | | + pure (\x_0 -> \x_1 -> x_0)+|   |       | | ` pure (\x_0 -> x_0)+|   |       | ` chainPost+|   |       |   + ref name+|   |       |   ` <*>+|   |       |     + <*>+|   |       |     | + pure (\x_0 -> \x_1 -> \x_2 -> x_0 x_2 x_1)+|   |       |     | ` pure (\x_0 -> \x_1 -> x_0)+|   |       |     ` satisfy Parsers.Nandlang.nandIdentLetter+|   |       ` ref name+|   ` ref name++ let name+| ` <*>+|   + <*>+|   | + pure (\x_0 -> \x_1 -> x_0)+|   | ` <*>+|   |   + <*>+|   |   | + pure (\x_0 -> \x_1 -> x_0)+|   |   | ` pure '('+|   |   ` satisfy ((GHC.Classes.==) '(')+|   ` ref name++ let name+| ` <*>+|   + <*>+|   | + pure (\x_0 -> \x_1 -> x_0)+|   | ` <*>+|   |   + <*>+|   |   | + pure (\x_0 -> \x_1 -> x_0)+|   |   | ` pure ')'+|   |   ` satisfy ((GHC.Classes.==) ')')+|   ` ref name++ let name+| ` <*>+|   + <*>+|   | + pure (\x_0 -> \x_1 -> x_0)+|   | ` <*>+|   |   + <*>+|   |   | + pure (\x_0 -> \x_1 -> x_0)+|   |   | ` pure ','+|   |   ` satisfy ((GHC.Classes.==) ',')+|   ` ref name++ let name+| ` <*>+|   + <*>+|   | + pure (\x_0 -> \x_1 -> x_0)+|   | ` <*>+|   |   + <*>+|   |   | + pure (\x_0 -> \x_1 -> x_0)+|   |   | ` pure ';'+|   |   ` satisfy ((GHC.Classes.==) ';')+|   ` ref name++ let name+| ` <*>+|   + pure (\x_0 -> \x_1 -> \x_2 -> x_0 x_2 x_1)+|   ` pure (\x_0 -> \x_1 -> x_0)++ let name+| ` <|>+|   + <*>+|   | + <*>+|   | | + pure (\x_0 -> \x_1 -> x_0)+|   | | ` pure GHC.Tuple.()+|   | ` <*>+|   |   + <*>+|   |   | + <*>+|   |   | | + pure (\x_0 -> \x_1 -> x_0)+|   |   | | ` pure (\x_0 -> x_0)+|   |   | ` ref name+|   |   ` <*>+|   |     + <*>+|   |     | + <*>+|   |     | | + pure (\x_0 -> \x_1 -> x_0)+|   |     | | ` pure (\x_0 -> x_0)+|   |     | ` chainPost+|   |     |   + ref name+|   |     |   ` <*>+|   |     |     + ref name+|   |     |     ` <*>+|   |     |       + <*>+|   |     |       | + <*>+|   |     |       | | + pure (\x_0 -> \x_1 -> x_0)+|   |     |       | | ` pure (\x_0 -> x_0)+|   |     |       | ` ref name+|   |     |       ` ref name+|   |     ` ref name+|   ` ref name++ let name+| ` <|>+|   + <|>+|   | + <*>+|   | | + <*>+|   | | | + <*>+|   | | | | + pure (\x_0 -> \x_1 -> x_0)+|   | | | | ` pure (\x_0 -> x_0)+|   | | | ` <|>+|   | | |   + <*>+|   | | |   | + <*>+|   | | |   | | + pure (\x_0 -> \x_1 -> x_0)+|   | | |   | | ` pure '0'+|   | | |   | ` satisfy ((GHC.Classes.==) '0')+|   | | |   ` <*>+|   | | |     + <*>+|   | | |     | + pure (\x_0 -> \x_1 -> x_0)+|   | | |     | ` pure '1'+|   | | |     ` satisfy ((GHC.Classes.==) '1')+|   | | ` ref name+|   | ` <*>+|   |   + <*>+|   |   | + pure (\x_0 -> \x_1 -> x_0)+|   |   | ` <*>+|   |   |   + <*>+|   |   |   | + <*>+|   |   |   | | + pure (\x_0 -> \x_1 -> x_0)+|   |   |   | | ` pure (\x_0 -> x_0)+|   |   |   | ` <*>+|   |   |   |   + <*>+|   |   |   |   | + pure (\x_0 -> \x_1 -> x_0)+|   |   |   |   | ` pure '\''+|   |   |   |   ` satisfy ((GHC.Classes.==) '\'')+|   |   |   ` <|>+|   |   |     + <*>+|   |   |     | + <*>+|   |   |     | | + <*>+|   |   |     | | | + pure (\x_0 -> \x_1 -> x_0)+|   |   |     | | | ` pure (\x_0 -> x_0)+|   |   |     | | ` satisfy Parsers.Nandlang.nandStringLetter+|   |   |     | ` ref name+|   |   |     ` <*>+|   |   |       + <*>+|   |   |       | + <*>+|   |   |       | | + pure (\x_0 -> \x_1 -> x_0)+|   |   |       | | ` pure (\x_0 -> x_0)+|   |   |       | ` <*>+|   |   |       |   + <*>+|   |   |       |   | + pure (\x_0 -> \x_1 -> x_0)+|   |   |       |   | ` pure '\\'+|   |   |       |   ` satisfy ((GHC.Classes.==) '\\')+|   |   |       ` <*>+|   |   |         + <*>+|   |   |         | + <*>+|   |   |         | | + pure (\x_0 -> \x_1 -> x_0)+|   |   |         | | ` pure (\x_0 -> x_0)+|   |   |         | ` satisfy (\t_0 -> ('0' GHC.Classes.== t_0) GHC.Classes.|| (('t' GHC.Classes.== t_0) GHC.Classes.|| (('n' GHC.Classes.== t_0) GHC.Classes.|| (('v' GHC.Classes.== t_0) GHC.Classes.|| (('f' GHC.Classes.== t_0) GHC.Classes.|| (('r' GHC.Classes.== t_0) GHC.Classes.|| GHC.Types.False))))))+|   |   |         ` ref name+|   |   ` <*>+|   |     + <*>+|   |     | + pure (\x_0 -> \x_1 -> x_0)+|   |     | ` <*>+|   |     |   + <*>+|   |     |   | + pure (\x_0 -> \x_1 -> x_0)+|   |     |   | ` pure '\''+|   |     |   ` satisfy ((GHC.Classes.==) '\'')+|   |     ` ref name+|   ` <*>+|     + <*>+|     | + <*>+|     | | + pure (\x_0 -> \x_1 -> x_0)+|     | | ` pure (\x_0 -> x_0)+|     | ` ref name+|     ` <|>+|       + <*>+|       | + <*>+|       | | + pure (\x_0 -> \x_1 -> x_0)+|       | | ` pure GHC.Tuple.()+|       | ` <|>+|       |   + <*>+|       |   | + <*>+|       |   | | + pure (\x_0 -> \x_1 -> x_0)+|       |   | | ` <*>+|       |   | |   + <*>+|       |   | |   | + <*>+|       |   | |   | | + pure (\x_0 -> \x_1 -> x_0)+|       |   | |   | | ` pure (\x_0 -> x_0)+|       |   | |   | ` ref name+|       |   | |   ` <|>+|       |   | |     + <*>+|       |   | |     | + <*>+|       |   | |     | | + pure (\x_0 -> \x_1 -> x_0)+|       |   | |     | | ` pure GHC.Tuple.()+|       |   | |     | ` <*>+|       |   | |     |   + <*>+|       |   | |     |   | + <*>+|       |   | |     |   | | + pure (\x_0 -> \x_1 -> x_0)+|       |   | |     |   | | ` pure (\x_0 -> x_0)+|       |   | |     |   | ` rec name+|       |   | |     |   ` <*>+|       |   | |     |     + <*>+|       |   | |     |     | + <*>+|       |   | |     |     | | + pure (\x_0 -> \x_1 -> x_0)+|       |   | |     |     | | ` pure (\x_0 -> x_0)+|       |   | |     |     | ` chainPost+|       |   | |     |     |   + ref name+|       |   | |     |     |   ` <*>+|       |   | |     |     |     + ref name+|       |   | |     |     |     ` <*>+|       |   | |     |     |       + <*>+|       |   | |     |     |       | + <*>+|       |   | |     |     |       | | + pure (\x_0 -> \x_1 -> x_0)+|       |   | |     |     |       | | ` pure (\x_0 -> x_0)+|       |   | |     |     |       | ` ref name+|       |   | |     |     |       ` rec name+|       |   | |     |     ` ref name+|       |   | |     ` ref name+|       |   | ` ref name+|       |   ` ref name+|       ` ref name++ let name+| ` pure GHC.Tuple.()++ let name+| ` pure GHC.Tuple.()++ let name+| ` satisfy (\t_0 -> ('0' GHC.Classes.== t_0) GHC.Classes.|| (('1' GHC.Classes.== t_0) GHC.Classes.|| (('2' GHC.Classes.== t_0) GHC.Classes.|| (('3' GHC.Classes.== t_0) GHC.Classes.|| (('4' GHC.Classes.== t_0) GHC.Classes.|| (('5' GHC.Classes.== t_0) GHC.Classes.|| (('6' GHC.Classes.== t_0) GHC.Classes.|| (('7' GHC.Classes.== t_0) GHC.Classes.|| (('8' GHC.Classes.== t_0) GHC.Classes.|| (('9' GHC.Classes.== t_0) GHC.Classes.|| GHC.Types.False))))))))))+` <*>+  + pure GHC.Show.show+  ` <*>+    + <*>+    | + pure (\x_0 -> \x_1 -> x_0)+    | ` <*>+    |   + <*>+    |   | + <*>+    |   | | + pure (\x_0 -> \x_1 -> x_0)+    |   | | ` pure (\x_0 -> x_0)+    |   | ` ref name+    |   ` <*>+    |     + <*>+    |     | + <*>+    |     | | + pure (\x_0 -> \x_1 -> x_0)+    |     | | ` pure (\x_0 -> x_0)+    |     | ` chainPost+    |     |   + ref name+    |     |   ` <*>+    |     |     + <*>+    |     |     | + pure (\x_0 -> \x_1 -> \x_2 -> x_0 x_2 x_1)+    |     |     | ` pure (\x_0 -> \x_1 -> x_0)+    |     |     ` <*>+    |     |       + <*>+    |     |       | + <*>+    |     |       | | + pure (\x_0 -> \x_1 -> x_0)+    |     |       | | ` pure (\x_0 -> x_0)+    |     |       | ` <*>+    |     |       |   + <*>+    |     |       |   | + <*>+    |     |       |   | | + pure (\x_0 -> \x_1 -> x_0)+    |     |       |   | | ` pure (\x_0 -> x_0)+    |     |       |   | ` <*>+    |     |       |   |   + <*>+    |     |       |   |   | + <*>+    |     |       |   |   | | + pure (\x_0 -> \x_1 -> x_0)+    |     |       |   |   | | ` pure (\x_0 -> x_0)+    |     |       |   |   | ` <*>+    |     |       |   |   |   + <*>+    |     |       |   |   |   | + <*>+    |     |       |   |   |   | | + pure (\x_0 -> \x_1 -> x_0)+    |     |       |   |   |   | | ` pure (\x_0 -> x_0)+    |     |       |   |   |   | ` try+    |     |       |   |   |   |   ` <*>+    |     |       |   |   |   |     + <*>+    |     |       |   |   |   |     | + pure (GHC.Types.:)+    |     |       |   |   |   |     | ` <*>+    |     |       |   |   |   |     |   + <*>+    |     |       |   |   |   |     |   | + pure (\x_0 -> \x_1 -> x_0)+    |     |       |   |   |   |     |   | ` pure 'f'+    |     |       |   |   |   |     |   ` satisfy ((GHC.Classes.==) 'f')+    |     |       |   |   |   |     ` <*>+    |     |       |   |   |   |       + <*>+    |     |       |   |   |   |       | + pure (GHC.Types.:)+    |     |       |   |   |   |       | ` <*>+    |     |       |   |   |   |       |   + <*>+    |     |       |   |   |   |       |   | + pure (\x_0 -> \x_1 -> x_0)+    |     |       |   |   |   |       |   | ` pure 'u'+    |     |       |   |   |   |       |   ` satisfy ((GHC.Classes.==) 'u')+    |     |       |   |   |   |       ` <*>+    |     |       |   |   |   |         + <*>+    |     |       |   |   |   |         | + pure (GHC.Types.:)+    |     |       |   |   |   |         | ` <*>+    |     |       |   |   |   |         |   + <*>+    |     |       |   |   |   |         |   | + pure (\x_0 -> \x_1 -> x_0)+    |     |       |   |   |   |         |   | ` pure 'n'+    |     |       |   |   |   |         |   ` satisfy ((GHC.Classes.==) 'n')+    |     |       |   |   |   |         ` <*>+    |     |       |   |   |   |           + <*>+    |     |       |   |   |   |           | + pure (GHC.Types.:)+    |     |       |   |   |   |           | ` <*>+    |     |       |   |   |   |           |   + <*>+    |     |       |   |   |   |           |   | + pure (\x_0 -> \x_1 -> x_0)+    |     |       |   |   |   |           |   | ` pure 'c'+    |     |       |   |   |   |           |   ` satisfy ((GHC.Classes.==) 'c')+    |     |       |   |   |   |           ` <*>+    |     |       |   |   |   |             + <*>+    |     |       |   |   |   |             | + pure (GHC.Types.:)+    |     |       |   |   |   |             | ` <*>+    |     |       |   |   |   |             |   + <*>+    |     |       |   |   |   |             |   | + pure (\x_0 -> \x_1 -> x_0)+    |     |       |   |   |   |             |   | ` pure 't'+    |     |       |   |   |   |             |   ` satisfy ((GHC.Classes.==) 't')+    |     |       |   |   |   |             ` <*>+    |     |       |   |   |   |               + <*>+    |     |       |   |   |   |               | + pure (GHC.Types.:)+    |     |       |   |   |   |               | ` <*>+    |     |       |   |   |   |               |   + <*>+    |     |       |   |   |   |               |   | + pure (\x_0 -> \x_1 -> x_0)+    |     |       |   |   |   |               |   | ` pure 'i'+    |     |       |   |   |   |               |   ` satisfy ((GHC.Classes.==) 'i')+    |     |       |   |   |   |               ` <*>+    |     |       |   |   |   |                 + <*>+    |     |       |   |   |   |                 | + pure (GHC.Types.:)+    |     |       |   |   |   |                 | ` <*>+    |     |       |   |   |   |                 |   + <*>+    |     |       |   |   |   |                 |   | + pure (\x_0 -> \x_1 -> x_0)+    |     |       |   |   |   |                 |   | ` pure 'o'+    |     |       |   |   |   |                 |   ` satisfy ((GHC.Classes.==) 'o')+    |     |       |   |   |   |                 ` <*>+    |     |       |   |   |   |                   + <*>+    |     |       |   |   |   |                   | + pure (GHC.Types.:)+    |     |       |   |   |   |                   | ` <*>+    |     |       |   |   |   |                   |   + <*>+    |     |       |   |   |   |                   |   | + pure (\x_0 -> \x_1 -> x_0)+    |     |       |   |   |   |                   |   | ` pure 'n'+    |     |       |   |   |   |                   |   ` satisfy ((GHC.Classes.==) 'n')+    |     |       |   |   |   |                   ` pure GHC.Types.[]+    |     |       |   |   |   ` ref name+    |     |       |   |   ` ref name+    |     |       |   ` <*>+    |     |       |     + <*>+    |     |       |     | + pure (\x_0 -> \x_1 -> x_0)+    |     |       |     | ` <*>+    |     |       |     |   + <*>+    |     |       |     |   | + <*>+    |     |       |     |   | | + pure (\x_0 -> \x_1 -> x_0)+    |     |       |     |   | | ` pure (\x_0 -> x_0)+    |     |       |     |   | ` ref name+    |     |       |     |   ` <*>+    |     |       |     |     + <*>+    |     |       |     |     | + <*>+    |     |       |     |     | | + pure (\x_0 -> \x_1 -> x_0)+    |     |       |     |     | | ` pure (\x_0 -> x_0)+    |     |       |     |     | ` ref name+    |     |       |     |     ` <|>+    |     |       |     |       + <*>+    |     |       |     |       | + <*>+    |     |       |     |       | | + pure (\x_0 -> \x_1 -> x_0)+    |     |       |     |       | | ` pure GHC.Tuple.()+    |     |       |     |       | ` <*>+    |     |       |     |       |   + <*>+    |     |       |     |       |   | + <*>+    |     |       |     |       |   | | + pure (\x_0 -> \x_1 -> x_0)+    |     |       |     |       |   | | ` pure (\x_0 -> x_0)+    |     |       |     |       |   | ` <*>+    |     |       |     |       |   |   + <*>+    |     |       |     |       |   |   | + pure (\x_0 -> \x_1 -> x_0)+    |     |       |     |       |   |   | ` <*>+    |     |       |     |       |   |   |   + <*>+    |     |       |     |       |   |   |   | + pure (\x_0 -> \x_1 -> x_0)+    |     |       |     |       |   |   |   | ` pure ':'+    |     |       |     |       |   |   |   ` satisfy ((GHC.Classes.==) ':')+    |     |       |     |       |   |   ` ref name+    |     |       |     |       |   ` ref name+    |     |       |     |       ` ref name+    |     |       |     ` ref name+    |     |       ` ref name+    |     ` ref name+    ` eof
+ tests/Golden/Grammar/ViewGrammar/G15.expected.txt view
@@ -0,0 +1,22 @@+lets+` <*>+  + pure GHC.Show.show+  ` <*>+    + <*>+    | + pure (\x_0 -> \x_1 -> x_0)+    | ` <|>+    |   + <*>+    |   | + <*>+    |   | | + pure (\x_0 -> \x_1 -> x_0)+    |   | | ` pure 'a'+    |   | ` satisfy ((GHC.Classes.==) 'a')+    |   ` <*>+    |     + <*>+    |     | + pure (\x_0 -> \x_1 -> x_0)+    |     | ` pure 'b'+    |     ` satisfy ((GHC.Classes.==) 'b')+    ` <*>+      + <*>+      | + pure (\x_0 -> \x_1 -> x_0)+      | ` pure 'c'+      ` satisfy ((GHC.Classes.==) 'c')
+ tests/Golden/Grammar/ViewGrammar/G16.expected.txt view
@@ -0,0 +1,28 @@+lets+` <*>+  + pure GHC.Show.show+  ` <*>+    + <*>+    | + pure (\x_0 -> \x_1 -> x_0)+    | ` <|>+    |   + <|>+    |   | + <*>+    |   | | + <*>+    |   | | | + pure (\x_0 -> \x_1 -> x_0)+    |   | | | ` pure 'a'+    |   | | ` satisfy ((GHC.Classes.==) 'a')+    |   | ` <*>+    |   |   + <*>+    |   |   | + pure (\x_0 -> \x_1 -> x_0)+    |   |   | ` pure 'b'+    |   |   ` satisfy ((GHC.Classes.==) 'b')+    |   ` <*>+    |     + <*>+    |     | + pure (\x_0 -> \x_1 -> x_0)+    |     | ` pure 'c'+    |     ` satisfy ((GHC.Classes.==) 'c')+    ` <*>+      + <*>+      | + pure (\x_0 -> \x_1 -> x_0)+      | ` pure 'd'+      ` satisfy ((GHC.Classes.==) 'd')
+ tests/Golden/Grammar/ViewGrammar/G17.expected.txt view
@@ -0,0 +1,12 @@+lets++ let name+| ` get reg_1+` <*>+  + pure GHC.Show.show+  ` new reg_1+    + satisfy (\x_0 -> GHC.Types.True)+    ` <*>+      + <*>+      | + pure GHC.Tuple.(,)+      | ` ref name+      ` ref name
+ tests/Golden/Grammar/ViewGrammar/G18.expected.txt view
@@ -0,0 +1,48 @@+lets+` <*>+  + pure GHC.Show.show+  ` <|>+    + try+    | ` <*>+    |   + <*>+    |   | + pure (GHC.Types.:)+    |   | ` <*>+    |   |   + <*>+    |   |   | + pure (\x_0 -> \x_1 -> x_0)+    |   |   | ` pure 'a'+    |   |   ` satisfy ((GHC.Classes.==) 'a')+    |   ` <*>+    |     + <*>+    |     | + pure (GHC.Types.:)+    |     | ` <*>+    |     |   + <*>+    |     |   | + pure (\x_0 -> \x_1 -> x_0)+    |     |   | ` pure 'b'+    |     |   ` satisfy ((GHC.Classes.==) 'b')+    |     ` <*>+    |       + <*>+    |       | + pure (GHC.Types.:)+    |       | ` <*>+    |       |   + <*>+    |       |   | + pure (\x_0 -> \x_1 -> x_0)+    |       |   | ` pure 'c'+    |       |   ` satisfy ((GHC.Classes.==) 'c')+    |       ` pure GHC.Types.[]+    ` try+      ` <*>+        + <*>+        | + pure (GHC.Types.:)+        | ` <*>+        |   + <*>+        |   | + pure (\x_0 -> \x_1 -> x_0)+        |   | ` pure 'd'+        |   ` satisfy ((GHC.Classes.==) 'd')+        ` <*>+          + <*>+          | + pure (GHC.Types.:)+          | ` <*>+          |   + <*>+          |   | + pure (\x_0 -> \x_1 -> x_0)+          |   | ` pure 'e'+          |   ` satisfy ((GHC.Classes.==) 'e')+          ` pure GHC.Types.[]
+ tests/Golden/Grammar/ViewGrammar/G19.expected.txt view
@@ -0,0 +1,83 @@+lets+` <*>+  + pure GHC.Show.show+  ` <|>+    + <|>+    | + try+    | | ` <*>+    | |   + <*>+    | |   | + pure (GHC.Types.:)+    | |   | ` <*>+    | |   |   + <*>+    | |   |   | + pure (\x_0 -> \x_1 -> x_0)+    | |   |   | ` pure 'a'+    | |   |   ` satisfy ((GHC.Classes.==) 'a')+    | |   ` <*>+    | |     + <*>+    | |     | + pure (GHC.Types.:)+    | |     | ` <*>+    | |     |   + <*>+    | |     |   | + pure (\x_0 -> \x_1 -> x_0)+    | |     |   | ` pure 'b'+    | |     |   ` satisfy ((GHC.Classes.==) 'b')+    | |     ` <*>+    | |       + <*>+    | |       | + pure (GHC.Types.:)+    | |       | ` <*>+    | |       |   + <*>+    | |       |   | + pure (\x_0 -> \x_1 -> x_0)+    | |       |   | ` pure 'c'+    | |       |   ` satisfy ((GHC.Classes.==) 'c')+    | |       ` pure GHC.Types.[]+    | ` try+    |   ` <*>+    |     + <*>+    |     | + pure (GHC.Types.:)+    |     | ` <*>+    |     |   + <*>+    |     |   | + pure (\x_0 -> \x_1 -> x_0)+    |     |   | ` pure 'd'+    |     |   ` satisfy ((GHC.Classes.==) 'd')+    |     ` <*>+    |       + <*>+    |       | + pure (GHC.Types.:)+    |       | ` <*>+    |       |   + <*>+    |       |   | + pure (\x_0 -> \x_1 -> x_0)+    |       |   | ` pure 'e'+    |       |   ` satisfy ((GHC.Classes.==) 'e')+    |       ` pure GHC.Types.[]+    ` try+      ` <*>+        + <*>+        | + pure (GHC.Types.:)+        | ` <*>+        |   + <*>+        |   | + pure (\x_0 -> \x_1 -> x_0)+        |   | ` pure 'f'+        |   ` satisfy ((GHC.Classes.==) 'f')+        ` <*>+          + <*>+          | + pure (GHC.Types.:)+          | ` <*>+          |   + <*>+          |   | + pure (\x_0 -> \x_1 -> x_0)+          |   | ` pure 'g'+          |   ` satisfy ((GHC.Classes.==) 'g')+          ` <*>+            + <*>+            | + pure (GHC.Types.:)+            | ` <*>+            |   + <*>+            |   | + pure (\x_0 -> \x_1 -> x_0)+            |   | ` pure 'h'+            |   ` satisfy ((GHC.Classes.==) 'h')+            ` <*>+              + <*>+              | + pure (GHC.Types.:)+              | ` <*>+              |   + <*>+              |   | + pure (\x_0 -> \x_1 -> x_0)+              |   | ` pure 'i'+              |   ` satisfy ((GHC.Classes.==) 'i')+              ` pure GHC.Types.[]
+ tests/Golden/Grammar/ViewGrammar/G2.expected.txt view
@@ -0,0 +1,29 @@+lets+` <*>+  + pure GHC.Show.show+  ` try+    ` <*>+      + <*>+      | + pure (GHC.Types.:)+      | ` <*>+      |   + <*>+      |   | + pure (\x_0 -> \x_1 -> x_0)+      |   | ` pure 'a'+      |   ` satisfy ((GHC.Classes.==) 'a')+      ` <*>+        + <*>+        | + pure (GHC.Types.:)+        | ` <*>+        |   + <*>+        |   | + pure (\x_0 -> \x_1 -> x_0)+        |   | ` pure 'b'+        |   ` satisfy ((GHC.Classes.==) 'b')+        ` <*>+          + <*>+          | + pure (GHC.Types.:)+          | ` <*>+          |   + <*>+          |   | + pure (\x_0 -> \x_1 -> x_0)+          |   | ` pure 'c'+          |   ` satisfy ((GHC.Classes.==) 'c')+          ` pure GHC.Types.[]
+ tests/Golden/Grammar/ViewGrammar/G20.expected.txt view
@@ -0,0 +1,69 @@+lets+` <*>+  + pure GHC.Show.show+  ` <*>+    + <*>+    | + <*>+    | | + pure (\x_0 -> \x_1 -> x_0)+    | | ` pure (\x_0 -> x_0)+    | ` <|>+    |   + try+    |   | ` <*>+    |   |   + <*>+    |   |   | + pure (GHC.Types.:)+    |   |   | ` <*>+    |   |   |   + <*>+    |   |   |   | + pure (\x_0 -> \x_1 -> x_0)+    |   |   |   | ` pure 'a'+    |   |   |   ` satisfy ((GHC.Classes.==) 'a')+    |   |   ` <*>+    |   |     + <*>+    |   |     | + pure (GHC.Types.:)+    |   |     | ` <*>+    |   |     |   + <*>+    |   |     |   | + pure (\x_0 -> \x_1 -> x_0)+    |   |     |   | ` pure 'b'+    |   |     |   ` satisfy ((GHC.Classes.==) 'b')+    |   |     ` <*>+    |   |       + <*>+    |   |       | + pure (GHC.Types.:)+    |   |       | ` <*>+    |   |       |   + <*>+    |   |       |   | + pure (\x_0 -> \x_1 -> x_0)+    |   |       |   | ` pure 'c'+    |   |       |   ` satisfy ((GHC.Classes.==) 'c')+    |   |       ` pure GHC.Types.[]+    |   ` try+    |     ` pure GHC.Types.[]+    ` <*>+      + <*>+      | + <*>+      | | + pure (\x_0 -> \x_1 -> x_0)+      | | ` pure (\x_0 -> x_0)+      | ` try+      |   ` <*>+      |     + <*>+      |     | + pure (GHC.Types.:)+      |     | ` <*>+      |     |   + <*>+      |     |   | + pure (\x_0 -> \x_1 -> x_0)+      |     |   | ` pure 'd'+      |     |   ` satisfy ((GHC.Classes.==) 'd')+      |     ` <*>+      |       + <*>+      |       | + pure (GHC.Types.:)+      |       | ` <*>+      |       |   + <*>+      |       |   | + pure (\x_0 -> \x_1 -> x_0)+      |       |   | ` pure 'e'+      |       |   ` satisfy ((GHC.Classes.==) 'e')+      |       ` <*>+      |         + <*>+      |         | + pure (GHC.Types.:)+      |         | ` <*>+      |         |   + <*>+      |         |   | + pure (\x_0 -> \x_1 -> x_0)+      |         |   | ` pure 'f'+      |         |   ` satisfy ((GHC.Classes.==) 'f')+      |         ` pure GHC.Types.[]+      ` pure GHC.Tuple.()
+ tests/Golden/Grammar/ViewGrammar/G3.expected.txt view
@@ -0,0 +1,12 @@+lets+` <*>+  + pure GHC.Show.show+  ` chainPre+    + <*>+    | + pure (GHC.Types.:)+    | ` <*>+    |   + <*>+    |   | + pure (\x_0 -> \x_1 -> x_0)+    |   | ` pure 'a'+    |   ` satisfy ((GHC.Classes.==) 'a')+    ` pure GHC.Types.[]
+ tests/Golden/Grammar/ViewGrammar/G4.expected.txt view
@@ -0,0 +1,47 @@+lets++ let name+| ` try+|   ` <*>+|     + <*>+|     | + pure (GHC.Types.:)+|     | ` <*>+|     |   + <*>+|     |   | + pure (\x_0 -> \x_1 -> x_0)+|     |   | ` pure 'a'+|     |   ` satisfy ((GHC.Classes.==) 'a')+|     ` <*>+|       + <*>+|       | + pure (GHC.Types.:)+|       | ` <*>+|       |   + <*>+|       |   | + pure (\x_0 -> \x_1 -> x_0)+|       |   | ` pure 'b'+|       |   ` satisfy ((GHC.Classes.==) 'b')+|       ` <*>+|         + <*>+|         | + pure (GHC.Types.:)+|         | ` <*>+|         |   + <*>+|         |   | + pure (\x_0 -> \x_1 -> x_0)+|         |   | ` pure 'c'+|         |   ` satisfy ((GHC.Classes.==) 'c')+|         ` <*>+|           + <*>+|           | + pure (GHC.Types.:)+|           | ` <*>+|           |   + <*>+|           |   | + pure (\x_0 -> \x_1 -> x_0)+|           |   | ` pure 'd'+|           |   ` satisfy ((GHC.Classes.==) 'd')+|           ` pure GHC.Types.[]+` <*>+  + pure GHC.Show.show+  ` <*>+    + <*>+    | + pure (GHC.Types.:)+    | ` ref name+    ` chainPre+      + <*>+      | + pure (GHC.Types.:)+      | ` ref name+      ` pure GHC.Types.[]
+ tests/Golden/Grammar/ViewGrammar/G5.expected.txt view
@@ -0,0 +1,51 @@+lets++ let name+| ` try+|   ` <*>+|     + <*>+|     | + pure (GHC.Types.:)+|     | ` <*>+|     |   + <*>+|     |   | + pure (\x_0 -> \x_1 -> x_0)+|     |   | ` pure 'a'+|     |   ` satisfy ((GHC.Classes.==) 'a')+|     ` <*>+|       + <*>+|       | + pure (GHC.Types.:)+|       | ` <*>+|       |   + <*>+|       |   | + pure (\x_0 -> \x_1 -> x_0)+|       |   | ` pure 'b'+|       |   ` satisfy ((GHC.Classes.==) 'b')+|       ` <*>+|         + <*>+|         | + pure (GHC.Types.:)+|         | ` <*>+|         |   + <*>+|         |   | + pure (\x_0 -> \x_1 -> x_0)+|         |   | ` pure 'c'+|         |   ` satisfy ((GHC.Classes.==) 'c')+|         ` <*>+|           + <*>+|           | + pure (GHC.Types.:)+|           | ` <*>+|           |   + <*>+|           |   | + pure (\x_0 -> \x_1 -> x_0)+|           |   | ` pure 'd'+|           |   ` satisfy ((GHC.Classes.==) 'd')+|           ` pure GHC.Types.[]+` <*>+  + pure GHC.Show.show+  ` <*>+    + <*>+    | + pure (\x_0 -> \x_1 -> x_0)+    | ` <*>+    |   + <*>+    |   | + pure (GHC.Types.:)+    |   | ` ref name+    |   ` chainPre+    |     + <*>+    |     | + pure (GHC.Types.:)+    |     | ` ref name+    |     ` pure GHC.Types.[]+    ` eof
+ tests/Golden/Grammar/ViewGrammar/G6.expected.txt view
@@ -0,0 +1,38 @@+lets+` <*>+  + pure GHC.Show.show+  ` <|>+    + <*>+    | + <*>+    | | + pure (GHC.Types.:)+    | | ` <*>+    | |   + <*>+    | |   | + pure (\x_0 -> \x_1 -> x_0)+    | |   | ` pure 'a'+    | |   ` satisfy ((GHC.Classes.==) 'a')+    | ` <*>+    |   + <*>+    |   | + pure (GHC.Types.:)+    |   | ` <*>+    |   |   + <*>+    |   |   | + pure (\x_0 -> \x_1 -> x_0)+    |   |   | ` pure 'a'+    |   |   ` satisfy ((GHC.Classes.==) 'a')+    |   ` pure GHC.Types.[]+    ` <*>+      + <*>+      | + pure (GHC.Types.:)+      | ` <*>+      |   + <*>+      |   | + pure (\x_0 -> \x_1 -> x_0)+      |   | ` pure 'a'+      |   ` satisfy ((GHC.Classes.==) 'a')+      ` <*>+        + <*>+        | + pure (GHC.Types.:)+        | ` <*>+        |   + <*>+        |   | + pure (\x_0 -> \x_1 -> x_0)+        |   | ` pure 'b'+        |   ` satisfy ((GHC.Classes.==) 'b')+        ` pure GHC.Types.[]
+ tests/Golden/Grammar/ViewGrammar/G7.expected.txt view
@@ -0,0 +1,40 @@+lets+` <*>+  + pure GHC.Show.show+  ` <|>+    + try+    | ` <*>+    |   + <*>+    |   | + pure (GHC.Types.:)+    |   | ` <*>+    |   |   + <*>+    |   |   | + pure (\x_0 -> \x_1 -> x_0)+    |   |   | ` pure 'a'+    |   |   ` satisfy ((GHC.Classes.==) 'a')+    |   ` <*>+    |     + <*>+    |     | + pure (GHC.Types.:)+    |     | ` <*>+    |     |   + <*>+    |     |   | + pure (\x_0 -> \x_1 -> x_0)+    |     |   | ` pure 'a'+    |     |   ` satisfy ((GHC.Classes.==) 'a')+    |     ` pure GHC.Types.[]+    ` try+      ` <*>+        + <*>+        | + pure (GHC.Types.:)+        | ` <*>+        |   + <*>+        |   | + pure (\x_0 -> \x_1 -> x_0)+        |   | ` pure 'a'+        |   ` satisfy ((GHC.Classes.==) 'a')+        ` <*>+          + <*>+          | + pure (GHC.Types.:)+          | ` <*>+          |   + <*>+          |   | + pure (\x_0 -> \x_1 -> x_0)+          |   | ` pure 'b'+          |   ` satisfy ((GHC.Classes.==) 'b')+          ` pure GHC.Types.[]
+ tests/Golden/Grammar/ViewGrammar/G8.expected.txt view
@@ -0,0 +1,16 @@+lets+` <*>+  + pure GHC.Show.show+  ` <*>+    + <*>+    | + pure (\x_0 -> \x_1 -> x_0)+    | ` chainPre+    |   + <*>+    |   | + pure (GHC.Types.:)+    |   | ` <*>+    |   |   + <*>+    |   |   | + pure (\x_0 -> \x_1 -> x_0)+    |   |   | ` pure 'r'+    |   |   ` satisfy ((GHC.Classes.==) 'r')+    |   ` pure GHC.Types.[]+    ` eof
+ tests/Golden/Grammar/ViewGrammar/G9.expected.txt view
@@ -0,0 +1,4 @@+lets+` <*>+  + pure GHC.Show.show+  ` eof
+ tests/Golden/Machine.hs view
@@ -0,0 +1,41 @@+{-# LANGUAGE DataKinds #-} -- For using P.viewMachine+{-# LANGUAGE FlexibleContexts #-} -- For machines+{-# LANGUAGE GADTs #-} -- For machines+{-# LANGUAGE TypeApplications #-} -- For P.viewMachine+module Golden.Machine where++import Data.Bool (Bool(..))+import Data.Char (Char)+import Control.Monad (Monad(..))+import Data.Int (Int)+import Data.Function (($), (.))+import Data.Functor ((<$>))+import Data.Semigroup (Semigroup(..))+import Data.String (String, IsString(..))+import Data.Text (Text)+import System.IO (IO)+import Test.Tasty+import Test.Tasty.Golden+import Text.Show (Show(..))+import qualified Data.List as List++import Golden.Utils+import Grammar+import qualified Symantic.Parser as P++goldens :: TestTree+goldens = testGroup "Machine" $+  (\f -> List.zipWith f (machines @Text) [1::Int ..]) $ \mach g ->+  let machineFile = getGoldenDir $ "Machine/G"<>show g<>".expected.txt" in+  goldenVsStringDiff ("G"<>show g) goldenDiff machineFile $ do+    resetTHNameCounter+    m <- mach+    return $ fromString $ show $+      P.viewMachine @'False m++machines ::+  P.InputToken inp ~ Char =>+  P.Cursorable (P.Cursor inp) =>+  P.Machinable (P.InputToken inp) repr =>+  [IO (repr inp '[] String)]+machines = P.optimizeMachine . P.optimizeGrammar <$> grammars
+ tests/Golden/Machine/G1.expected.txt view
@@ -0,0 +1,25 @@+pushValue (\x_0 -> GHC.Show.show 'a')+  minReads=1+  mayRaise=[ExceptionFailure]+  alwaysRaise=[]+  freeRegs=[]+comment "satisfy ((GHC.Classes.==) 'a')"+  minReads=1+  mayRaise=[ExceptionFailure]+  alwaysRaise=[]+  freeRegs=[]+read ((GHC.Classes.==) 'a')+  minReads=1+  mayRaise=[ExceptionFailure]+  alwaysRaise=[]+  freeRegs=[]+lift2Value (\x_0 -> \x_1 -> x_0 x_1)+  minReads=0+  mayRaise=[]+  alwaysRaise=[]+  freeRegs=[]+ret+  minReads=0+  mayRaise=[]+  alwaysRaise=[]+  freeRegs=[]
+ tests/Golden/Machine/G10.expected.txt view
@@ -0,0 +1,111 @@+pushValue GHC.Show.show+  minReads=1+  mayRaise=[ExceptionFailure]+  alwaysRaise=[]+  freeRegs=[]+join join+  minReads=0+  mayRaise=[]+  alwaysRaise=[]+  freeRegs=[]+| lift2Value (\x_0 -> \x_1 -> x_0 x_1)+|   minReads=0+|   mayRaise=[]+|   alwaysRaise=[]+|   freeRegs=[]+| ret+|   minReads=0+|   mayRaise=[]+|   alwaysRaise=[]+|   freeRegs=[]+catch ExceptionFailure+  minReads=1+  mayRaise=[ExceptionFailure]+  alwaysRaise=[]+  freeRegs=[]+| <catchScope>+| | pushValue (\x_0 -> 'a')+| |   minReads=1+| |   mayRaise=[ExceptionFailure]+| |   alwaysRaise=[]+| |   freeRegs=[]+| | comment "satisfy ((GHC.Classes.==) 'a')"+| |   minReads=1+| |   mayRaise=[ExceptionFailure]+| |   alwaysRaise=[]+| |   freeRegs=[]+| | read ((GHC.Classes.==) 'a')+| |   minReads=1+| |   mayRaise=[ExceptionFailure]+| |   alwaysRaise=[]+| |   freeRegs=[]+| | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| |   minReads=0+| |   mayRaise=[]+| |   alwaysRaise=[]+| |   freeRegs=[]+| | commit ExceptionFailure+| |   minReads=0+| |   mayRaise=[]+| |   alwaysRaise=[]+| |   freeRegs=[]+| | refJoin join+| |   minReads=0+| |   mayRaise=[]+| |   alwaysRaise=[]+| |   freeRegs=[]+| <onException ExceptionFailure>+| | comment "raiseAgainIfConsumed"+| |   minReads=1+| |   mayRaise=[ExceptionFailure]+| |   alwaysRaise=[]+| |   freeRegs=[]+| | saveInput+| |   minReads=1+| |   mayRaise=[ExceptionFailure]+| |   alwaysRaise=[]+| |   freeRegs=[]+| | lift2Value (\(Data.Text.Internal.Text _ i_0 _) (Data.Text.Internal.Text _+| |                                                                j_1+| |                                                                _) -> i_0 GHC.Classes.== j_1)+| |   minReads=1+| |   mayRaise=[ExceptionFailure]+| |   alwaysRaise=[]+| |   freeRegs=[]+| | choicesBranch+| |   minReads=1+| |   mayRaise=[ExceptionFailure]+| |   alwaysRaise=[]+| |   freeRegs=[]+| | | <branch (\x_0 -> x_0)>+| | | | pushValue (\x_0 -> 'b')+| | | |   minReads=1+| | | |   mayRaise=[ExceptionFailure]+| | | |   alwaysRaise=[]+| | | |   freeRegs=[]+| | | | comment "satisfy ((GHC.Classes.==) 'b')"+| | | |   minReads=1+| | | |   mayRaise=[ExceptionFailure]+| | | |   alwaysRaise=[]+| | | |   freeRegs=[]+| | | | read ((GHC.Classes.==) 'b')+| | | |   minReads=1+| | | |   mayRaise=[ExceptionFailure]+| | | |   alwaysRaise=[]+| | | |   freeRegs=[]+| | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| | | |   minReads=0+| | | |   mayRaise=[]+| | | |   alwaysRaise=[]+| | | |   freeRegs=[]+| | | | refJoin join+| | | |   minReads=0+| | | |   mayRaise=[]+| | | |   alwaysRaise=[]+| | | |   freeRegs=[]+| | | <default>+| | | | fail []+| | | |   minReads=0+| | | |   mayRaise=[ExceptionFailure]+| | | |   alwaysRaise=[ExceptionFailure]+| | | |   freeRegs=[]
+ tests/Golden/Machine/G11.expected.txt view
@@ -0,0 +1,141 @@+pushValue (\x_0 -> \x_1 -> GHC.Show.show x_0)+  minReads=1+  mayRaise=[ExceptionFailure]+  alwaysRaise=[]+  freeRegs=[]+pushValue (\x_0 -> x_0)+  minReads=1+  mayRaise=[ExceptionFailure]+  alwaysRaise=[]+  freeRegs=[]+newRegister reg+  minReads=1+  mayRaise=[ExceptionFailure]+  alwaysRaise=[]+  freeRegs=[]+iter loop+  minReads=1+  mayRaise=[ExceptionFailure]+  alwaysRaise=[]+  freeRegs=[reg]+| <ok>+| | pushValue (\x_0 -> (GHC.Types.:) 'a')+| |   minReads=1+| |   mayRaise=[ExceptionFailure]+| |   alwaysRaise=[]+| |   freeRegs=[reg]+| | comment "satisfy ((GHC.Classes.==) 'a')"+| |   minReads=1+| |   mayRaise=[ExceptionFailure]+| |   alwaysRaise=[]+| |   freeRegs=[reg]+| | read ((GHC.Classes.==) 'a')+| |   minReads=1+| |   mayRaise=[ExceptionFailure]+| |   alwaysRaise=[]+| |   freeRegs=[reg]+| | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| |   minReads=0+| |   mayRaise=[]+| |   alwaysRaise=[]+| |   freeRegs=[reg]+| | pushValue (\x_0 -> \x_1 -> \x_2 -> x_1 (x_0 x_2))+| |   minReads=0+| |   mayRaise=[]+| |   alwaysRaise=[]+| |   freeRegs=[reg]+| | lift2Value (\x_0 -> \x_1 -> x_1 x_0)+| |   minReads=0+| |   mayRaise=[]+| |   alwaysRaise=[]+| |   freeRegs=[reg]+| | readRegister reg+| |   minReads=0+| |   mayRaise=[]+| |   alwaysRaise=[]+| |   freeRegs=[reg]+| | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| |   minReads=0+| |   mayRaise=[]+| |   alwaysRaise=[]+| |   freeRegs=[reg]+| | writeRegister reg+| |   minReads=0+| |   mayRaise=[]+| |   alwaysRaise=[]+| |   freeRegs=[reg]+| | jump loop+| |   minReads=0+| |   mayRaise=[]+| |   alwaysRaise=[]+| |   freeRegs=[]+| <ko>+| | comment "raiseAgainIfConsumed"+| |   minReads=1+| |   mayRaise=[ExceptionFailure]+| |   alwaysRaise=[]+| |   freeRegs=[reg]+| | saveInput+| |   minReads=1+| |   mayRaise=[ExceptionFailure]+| |   alwaysRaise=[]+| |   freeRegs=[reg]+| | lift2Value (\(Data.Text.Internal.Text _ i_0 _) (Data.Text.Internal.Text _+| |                                                                j_1+| |                                                                _) -> i_0 GHC.Classes.== j_1)+| |   minReads=1+| |   mayRaise=[ExceptionFailure]+| |   alwaysRaise=[]+| |   freeRegs=[reg]+| | choicesBranch+| |   minReads=1+| |   mayRaise=[ExceptionFailure]+| |   alwaysRaise=[]+| |   freeRegs=[reg]+| | | <branch (\x_0 -> x_0)>+| | | | readRegister reg+| | | |   minReads=1+| | | |   mayRaise=[ExceptionFailure]+| | | |   alwaysRaise=[]+| | | |   freeRegs=[reg]+| | | | pushValue GHC.Types.[]+| | | |   minReads=1+| | | |   mayRaise=[ExceptionFailure]+| | | |   alwaysRaise=[]+| | | |   freeRegs=[]+| | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| | | |   minReads=1+| | | |   mayRaise=[ExceptionFailure]+| | | |   alwaysRaise=[]+| | | |   freeRegs=[]+| | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| | | |   minReads=1+| | | |   mayRaise=[ExceptionFailure]+| | | |   alwaysRaise=[]+| | | |   freeRegs=[]+| | | | comment "satisfy ((GHC.Classes.==) 'b')"+| | | |   minReads=1+| | | |   mayRaise=[ExceptionFailure]+| | | |   alwaysRaise=[]+| | | |   freeRegs=[]+| | | | read ((GHC.Classes.==) 'b')+| | | |   minReads=1+| | | |   mayRaise=[ExceptionFailure]+| | | |   alwaysRaise=[]+| | | |   freeRegs=[]+| | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| | | |   minReads=0+| | | |   mayRaise=[]+| | | |   alwaysRaise=[]+| | | |   freeRegs=[]+| | | | ret+| | | |   minReads=0+| | | |   mayRaise=[]+| | | |   alwaysRaise=[]+| | | |   freeRegs=[]+| | | <default>+| | | | fail []+| | | |   minReads=0+| | | |   mayRaise=[ExceptionFailure]+| | | |   alwaysRaise=[ExceptionFailure]+| | | |   freeRegs=[]
+ tests/Golden/Machine/G12.expected.txt view
@@ -0,0 +1,259 @@+pushValue (\x_0 -> \x_1 -> GHC.Show.show x_0)+  minReads=0+  mayRaise=[ExceptionFailure]+  alwaysRaise=[]+  freeRegs=[]+pushValue (\x_0 -> x_0)+  minReads=0+  mayRaise=[ExceptionFailure]+  alwaysRaise=[]+  freeRegs=[]+newRegister reg+  minReads=0+  mayRaise=[ExceptionFailure]+  alwaysRaise=[]+  freeRegs=[]+iter loop+  minReads=0+  mayRaise=[ExceptionFailure]+  alwaysRaise=[]+  freeRegs=[reg]+| <ok>+| | pushValue (GHC.Types.:)+| |   minReads=1+| |   mayRaise=[ExceptionFailure]+| |   alwaysRaise=[]+| |   freeRegs=[reg]+| | comment "satisfy (\\t_0 -> ('a' GHC.Classes.== t_0) GHC.Classes.|| (('b' GHC.Classes.== t_0) GHC.Classes.|| (('c' GHC.Classes.== t_0) GHC.Classes.|| (('d' GHC.Classes.== t_0) GHC.Classes.|| GHC.Types.False))))"+| |   minReads=1+| |   mayRaise=[ExceptionFailure]+| |   alwaysRaise=[]+| |   freeRegs=[reg]+| | read (\t_0 -> ('a' GHC.Classes.== t_0) GHC.Classes.|| (('b' GHC.Classes.== t_0) GHC.Classes.|| (('c' GHC.Classes.== t_0) GHC.Classes.|| (('d' GHC.Classes.== t_0) GHC.Classes.|| GHC.Types.False))))+| |   minReads=1+| |   mayRaise=[ExceptionFailure]+| |   alwaysRaise=[]+| |   freeRegs=[reg]+| | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| |   minReads=0+| |   mayRaise=[]+| |   alwaysRaise=[]+| |   freeRegs=[reg]+| | pushValue (\x_0 -> \x_1 -> \x_2 -> x_1 (x_0 x_2))+| |   minReads=0+| |   mayRaise=[]+| |   alwaysRaise=[]+| |   freeRegs=[reg]+| | lift2Value (\x_0 -> \x_1 -> x_1 x_0)+| |   minReads=0+| |   mayRaise=[]+| |   alwaysRaise=[]+| |   freeRegs=[reg]+| | readRegister reg+| |   minReads=0+| |   mayRaise=[]+| |   alwaysRaise=[]+| |   freeRegs=[reg]+| | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| |   minReads=0+| |   mayRaise=[]+| |   alwaysRaise=[]+| |   freeRegs=[reg]+| | writeRegister reg+| |   minReads=0+| |   mayRaise=[]+| |   alwaysRaise=[]+| |   freeRegs=[reg]+| | jump loop+| |   minReads=0+| |   mayRaise=[]+| |   alwaysRaise=[]+| |   freeRegs=[]+| <ko>+| | comment "raiseAgainIfConsumed"+| |   minReads=0+| |   mayRaise=[ExceptionFailure]+| |   alwaysRaise=[]+| |   freeRegs=[reg]+| | saveInput+| |   minReads=0+| |   mayRaise=[ExceptionFailure]+| |   alwaysRaise=[]+| |   freeRegs=[reg]+| | lift2Value (\(Data.Text.Internal.Text _ i_0 _) (Data.Text.Internal.Text _+| |                                                                j_1+| |                                                                _) -> i_0 GHC.Classes.== j_1)+| |   minReads=0+| |   mayRaise=[ExceptionFailure]+| |   alwaysRaise=[]+| |   freeRegs=[reg]+| | choicesBranch+| |   minReads=0+| |   mayRaise=[ExceptionFailure]+| |   alwaysRaise=[]+| |   freeRegs=[reg]+| | | <branch (\x_0 -> x_0)>+| | | | readRegister reg+| | | |   minReads=0+| | | |   mayRaise=[ExceptionFailure]+| | | |   alwaysRaise=[]+| | | |   freeRegs=[reg]+| | | | pushValue GHC.Types.[]+| | | |   minReads=0+| | | |   mayRaise=[ExceptionFailure]+| | | |   alwaysRaise=[]+| | | |   freeRegs=[]+| | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| | | |   minReads=0+| | | |   mayRaise=[ExceptionFailure]+| | | |   alwaysRaise=[]+| | | |   freeRegs=[]+| | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| | | |   minReads=0+| | | |   mayRaise=[ExceptionFailure]+| | | |   alwaysRaise=[]+| | | |   freeRegs=[]+| | | | join join+| | | |   minReads=0+| | | |   mayRaise=[]+| | | |   alwaysRaise=[]+| | | |   freeRegs=[]+| | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| | | | |   minReads=0+| | | | |   mayRaise=[]+| | | | |   alwaysRaise=[]+| | | | |   freeRegs=[]+| | | | | ret+| | | | |   minReads=0+| | | | |   mayRaise=[]+| | | | |   alwaysRaise=[]+| | | | |   freeRegs=[]+| | | | catch ExceptionFailure+| | | |   minReads=0+| | | |   mayRaise=[ExceptionFailure]+| | | |   alwaysRaise=[]+| | | |   freeRegs=[]+| | | | | <catchScope>+| | | | | | comment "negLook"+| | | | | |   minReads=0+| | | | | |   mayRaise=[]+| | | | | |   alwaysRaise=[]+| | | | | |   freeRegs=[]+| | | | | | catch ExceptionFailure+| | | | | |   minReads=0+| | | | | |   mayRaise=[]+| | | | | |   alwaysRaise=[]+| | | | | |   freeRegs=[]+| | | | | | | <catchScope>+| | | | | | | | comment "negLook.ahead"+| | | | | | | |   minReads=1+| | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | |   alwaysRaise=[ExceptionFailure]+| | | | | | | |   freeRegs=[]+| | | | | | | | saveInput+| | | | | | | |   minReads=1+| | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | |   alwaysRaise=[ExceptionFailure]+| | | | | | | |   freeRegs=[]+| | | | | | | | comment "satisfy ((\\x_0 -> \\x_1 -> x_0) GHC.Types.True)"+| | | | | | | |   minReads=1+| | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | |   alwaysRaise=[ExceptionFailure]+| | | | | | | |   freeRegs=[]+| | | | | | | | read (\x_0 -> GHC.Types.True)+| | | | | | | |   minReads=1+| | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | |   alwaysRaise=[ExceptionFailure]+| | | | | | | |   freeRegs=[]+| | | | | | | | popValue+| | | | | | | |   minReads=0+| | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | |   alwaysRaise=[ExceptionFailure]+| | | | | | | |   freeRegs=[]+| | | | | | | | commit ExceptionFailure+| | | | | | | |   minReads=0+| | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | |   alwaysRaise=[ExceptionFailure]+| | | | | | | |   freeRegs=[]+| | | | | | | | loadInput+| | | | | | | |   minReads=0+| | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | |   alwaysRaise=[ExceptionFailure]+| | | | | | | |   freeRegs=[]+| | | | | | | | fail []+| | | | | | | |   minReads=0+| | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | |   alwaysRaise=[ExceptionFailure]+| | | | | | | |   freeRegs=[]+| | | | | | | <onException ExceptionFailure>+| | | | | | | | comment "negLook.reset"+| | | | | | | |   minReads=0+| | | | | | | |   mayRaise=[]+| | | | | | | |   alwaysRaise=[]+| | | | | | | |   freeRegs=[]+| | | | | | | | loadInput+| | | | | | | |   minReads=0+| | | | | | | |   mayRaise=[]+| | | | | | | |   alwaysRaise=[]+| | | | | | | |   freeRegs=[]+| | | | | | | | pushValue GHC.Tuple.()+| | | | | | | |   minReads=0+| | | | | | | |   mayRaise=[]+| | | | | | | |   alwaysRaise=[]+| | | | | | | |   freeRegs=[]+| | | | | | | | commit ExceptionFailure+| | | | | | | |   minReads=0+| | | | | | | |   mayRaise=[]+| | | | | | | |   alwaysRaise=[]+| | | | | | | |   freeRegs=[]+| | | | | | | | refJoin join+| | | | | | | |   minReads=0+| | | | | | | |   mayRaise=[]+| | | | | | | |   alwaysRaise=[]+| | | | | | | |   freeRegs=[]+| | | | | <onException ExceptionFailure>+| | | | | | comment "raiseAgainIfConsumed"+| | | | | |   minReads=0+| | | | | |   mayRaise=[ExceptionFailure]+| | | | | |   alwaysRaise=[]+| | | | | |   freeRegs=[]+| | | | | | saveInput+| | | | | |   minReads=0+| | | | | |   mayRaise=[ExceptionFailure]+| | | | | |   alwaysRaise=[]+| | | | | |   freeRegs=[]+| | | | | | lift2Value (\(Data.Text.Internal.Text _ i_0 _) (Data.Text.Internal.Text _+| | | | | |                                                                j_1+| | | | | |                                                                _) -> i_0 GHC.Classes.== j_1)+| | | | | |   minReads=0+| | | | | |   mayRaise=[ExceptionFailure]+| | | | | |   alwaysRaise=[]+| | | | | |   freeRegs=[]+| | | | | | choicesBranch+| | | | | |   minReads=0+| | | | | |   mayRaise=[ExceptionFailure]+| | | | | |   alwaysRaise=[]+| | | | | |   freeRegs=[]+| | | | | | | <branch (\x_0 -> x_0)>+| | | | | | | | comment "eof.fail"+| | | | | | | |   minReads=0+| | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | |   alwaysRaise=[ExceptionFailure]+| | | | | | | |   freeRegs=[]+| | | | | | | | fail [FailureEnd]+| | | | | | | |   minReads=0+| | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | |   alwaysRaise=[ExceptionFailure]+| | | | | | | |   freeRegs=[]+| | | | | | | <default>+| | | | | | | | fail []+| | | | | | | |   minReads=0+| | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | |   alwaysRaise=[ExceptionFailure]+| | | | | | | |   freeRegs=[]+| | | <default>+| | | | fail []+| | | |   minReads=0+| | | |   mayRaise=[ExceptionFailure]+| | | |   alwaysRaise=[ExceptionFailure]+| | | |   freeRegs=[]
+ tests/Golden/Machine/G13.expected.txt view
@@ -0,0 +1,535 @@+let name+  minReads=0+  mayRaise=[ExceptionFailure]+  alwaysRaise=[]+  freeRegs=[]+| pushValue (\x_0 -> GHC.Tuple.())+|   minReads=0+|   mayRaise=[ExceptionFailure]+|   alwaysRaise=[]+|   freeRegs=[]+| pushValue (\x_0 -> x_0)+|   minReads=0+|   mayRaise=[ExceptionFailure]+|   alwaysRaise=[]+|   freeRegs=[]+| newRegister reg+|   minReads=0+|   mayRaise=[ExceptionFailure]+|   alwaysRaise=[]+|   freeRegs=[]+| iter loop+|   minReads=0+|   mayRaise=[ExceptionFailure]+|   alwaysRaise=[]+|   freeRegs=[reg]+| | <ok>+| | | pushValue (\x_0 -> \x_1 -> x_1)+| | |   minReads=1+| | |   mayRaise=[ExceptionFailure]+| | |   alwaysRaise=[]+| | |   freeRegs=[reg]+| | | comment "satisfy (\\c_0 -> GHC.Classes.not (('<' GHC.Classes.== c_0) GHC.Classes.|| (('>' GHC.Classes.== c_0) GHC.Classes.|| (('+' GHC.Classes.== c_0) GHC.Classes.|| (('-' GHC.Classes.== c_0) GHC.Classes.|| ((',' GHC.Classes.== c_0) GHC.Classes.|| (('.' GHC.Classes.== c_0) GHC.Classes.|| (('[' GHC.Classes.== c_0) GHC.Classes.|| ((']' GHC.Classes.== c_0) GHC.Classes.|| GHC.Types.False)))))))))"+| | |   minReads=1+| | |   mayRaise=[ExceptionFailure]+| | |   alwaysRaise=[]+| | |   freeRegs=[reg]+| | | read (\c_0 -> GHC.Classes.not (('<' GHC.Classes.== c_0) GHC.Classes.|| (('>' GHC.Classes.== c_0) GHC.Classes.|| (('+' GHC.Classes.== c_0) GHC.Classes.|| (('-' GHC.Classes.== c_0) GHC.Classes.|| ((',' GHC.Classes.== c_0) GHC.Classes.|| (('.' GHC.Classes.== c_0) GHC.Classes.|| (('[' GHC.Classes.== c_0) GHC.Classes.|| ((']' GHC.Classes.== c_0) GHC.Classes.|| GHC.Types.False)))))))))+| | |   minReads=1+| | |   mayRaise=[ExceptionFailure]+| | |   alwaysRaise=[]+| | |   freeRegs=[reg]+| | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| | |   minReads=0+| | |   mayRaise=[]+| | |   alwaysRaise=[]+| | |   freeRegs=[reg]+| | | readRegister reg+| | |   minReads=0+| | |   mayRaise=[]+| | |   alwaysRaise=[]+| | |   freeRegs=[reg]+| | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| | |   minReads=0+| | |   mayRaise=[]+| | |   alwaysRaise=[]+| | |   freeRegs=[reg]+| | | writeRegister reg+| | |   minReads=0+| | |   mayRaise=[]+| | |   alwaysRaise=[]+| | |   freeRegs=[reg]+| | | jump loop+| | |   minReads=0+| | |   mayRaise=[]+| | |   alwaysRaise=[]+| | |   freeRegs=[]+| | <ko>+| | | comment "raiseAgainIfConsumed"+| | |   minReads=0+| | |   mayRaise=[ExceptionFailure]+| | |   alwaysRaise=[]+| | |   freeRegs=[reg]+| | | saveInput+| | |   minReads=0+| | |   mayRaise=[ExceptionFailure]+| | |   alwaysRaise=[]+| | |   freeRegs=[reg]+| | | lift2Value (\(Data.Text.Internal.Text _ i_0 _) (Data.Text.Internal.Text _+| | |                                                                j_1+| | |                                                                _) -> i_0 GHC.Classes.== j_1)+| | |   minReads=0+| | |   mayRaise=[ExceptionFailure]+| | |   alwaysRaise=[]+| | |   freeRegs=[reg]+| | | choicesBranch+| | |   minReads=0+| | |   mayRaise=[ExceptionFailure]+| | |   alwaysRaise=[]+| | |   freeRegs=[reg]+| | | | <branch (\x_0 -> x_0)>+| | | | | readRegister reg+| | | | |   minReads=0+| | | | |   mayRaise=[]+| | | | |   alwaysRaise=[]+| | | | |   freeRegs=[reg]+| | | | | pushValue GHC.Tuple.()+| | | | |   minReads=0+| | | | |   mayRaise=[]+| | | | |   alwaysRaise=[]+| | | | |   freeRegs=[]+| | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| | | | |   minReads=0+| | | | |   mayRaise=[]+| | | | |   alwaysRaise=[]+| | | | |   freeRegs=[]+| | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| | | | |   minReads=0+| | | | |   mayRaise=[]+| | | | |   alwaysRaise=[]+| | | | |   freeRegs=[]+| | | | | ret+| | | | |   minReads=0+| | | | |   mayRaise=[]+| | | | |   alwaysRaise=[]+| | | | |   freeRegs=[]+| | | | <default>+| | | | | fail []+| | | | |   minReads=0+| | | | |   mayRaise=[ExceptionFailure]+| | | | |   alwaysRaise=[ExceptionFailure]+| | | | |   freeRegs=[]+let name+  minReads=0+  mayRaise=[ExceptionFailure]+  alwaysRaise=[]+  freeRegs=[]+| pushValue (\x_0 -> x_0)+|   minReads=0+|   mayRaise=[ExceptionFailure]+|   alwaysRaise=[]+|   freeRegs=[]+| newRegister reg+|   minReads=0+|   mayRaise=[ExceptionFailure]+|   alwaysRaise=[]+|   freeRegs=[]+| iter loop+|   minReads=0+|   mayRaise=[ExceptionFailure]+|   alwaysRaise=[]+|   freeRegs=[reg]+| | <ok>+| | | pushValue (\x_0 -> \x_1 -> (GHC.Types.:) x_0)+| | |   minReads=1+| | |   mayRaise=[ExceptionFailure]+| | |   alwaysRaise=[]+| | |   freeRegs=[reg]+| | | join join+| | |   minReads=0+| | |   mayRaise=[ExceptionFailure]+| | |   alwaysRaise=[]+| | |   freeRegs=[reg]+| | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| | | |   minReads=0+| | | |   mayRaise=[ExceptionFailure]+| | | |   alwaysRaise=[]+| | | |   freeRegs=[reg]+| | | | call name+| | | |   minReads=0+| | | |   mayRaise=[ExceptionFailure]+| | | |   alwaysRaise=[]+| | | |   freeRegs=[reg]+| | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| | | |   minReads=0+| | | |   mayRaise=[]+| | | |   alwaysRaise=[]+| | | |   freeRegs=[reg]+| | | | pushValue (\x_0 -> \x_1 -> \x_2 -> x_1 (x_0 x_2))+| | | |   minReads=0+| | | |   mayRaise=[]+| | | |   alwaysRaise=[]+| | | |   freeRegs=[reg]+| | | | lift2Value (\x_0 -> \x_1 -> x_1 x_0)+| | | |   minReads=0+| | | |   mayRaise=[]+| | | |   alwaysRaise=[]+| | | |   freeRegs=[reg]+| | | | readRegister reg+| | | |   minReads=0+| | | |   mayRaise=[]+| | | |   alwaysRaise=[]+| | | |   freeRegs=[reg]+| | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| | | |   minReads=0+| | | |   mayRaise=[]+| | | |   alwaysRaise=[]+| | | |   freeRegs=[reg]+| | | | writeRegister reg+| | | |   minReads=0+| | | |   mayRaise=[]+| | | |   alwaysRaise=[]+| | | |   freeRegs=[reg]+| | | | jump loop+| | | |   minReads=0+| | | |   mayRaise=[]+| | | |   alwaysRaise=[]+| | | |   freeRegs=[]+| | | comment "look"+| | |   minReads=1+| | |   mayRaise=[ExceptionFailure]+| | |   alwaysRaise=[]+| | |   freeRegs=[reg]+| | | saveInput+| | |   minReads=1+| | |   mayRaise=[ExceptionFailure]+| | |   alwaysRaise=[]+| | |   freeRegs=[reg]+| | | comment "satisfy ((\\x_0 -> \\x_1 -> x_0) GHC.Types.True)"+| | |   minReads=1+| | |   mayRaise=[ExceptionFailure]+| | |   alwaysRaise=[]+| | |   freeRegs=[reg]+| | | read (\x_0 -> GHC.Types.True)+| | |   minReads=1+| | |   mayRaise=[ExceptionFailure]+| | |   alwaysRaise=[]+| | |   freeRegs=[reg]+| | | swapValue+| | |   minReads=0+| | |   mayRaise=[ExceptionFailure]+| | |   alwaysRaise=[]+| | |   freeRegs=[reg]+| | | loadInput+| | |   minReads=0+| | |   mayRaise=[ExceptionFailure]+| | |   alwaysRaise=[]+| | |   freeRegs=[reg]+| | | choicesBranch+| | |   minReads=1+| | |   mayRaise=[ExceptionFailure]+| | |   alwaysRaise=[]+| | |   freeRegs=[reg]+| | | | <branch (\x_0 -> (\x_1 -> \x_2 -> (GHC.Classes.==) x_1 x_2) '<' x_0)>+| | | | | pushValue (\x_0 -> Parsers.Brainfuck.Types.Backward)+| | | | |   minReads=1+| | | | |   mayRaise=[ExceptionFailure]+| | | | |   alwaysRaise=[]+| | | | |   freeRegs=[reg]+| | | | | comment "satisfy ((\\x_0 -> \\x_1 -> x_0) GHC.Types.True)"+| | | | |   minReads=1+| | | | |   mayRaise=[ExceptionFailure]+| | | | |   alwaysRaise=[]+| | | | |   freeRegs=[reg]+| | | | | read (\x_0 -> GHC.Types.True)+| | | | |   minReads=1+| | | | |   mayRaise=[ExceptionFailure]+| | | | |   alwaysRaise=[]+| | | | |   freeRegs=[reg]+| | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| | | | |   minReads=0+| | | | |   mayRaise=[ExceptionFailure]+| | | | |   alwaysRaise=[]+| | | | |   freeRegs=[reg]+| | | | | refJoin join+| | | | |   minReads=0+| | | | |   mayRaise=[ExceptionFailure]+| | | | |   alwaysRaise=[]+| | | | |   freeRegs=[reg]+| | | | <branch (\x_0 -> (\x_1 -> \x_2 -> (GHC.Classes.==) x_1 x_2) '>' x_0)>+| | | | | pushValue (\x_0 -> Parsers.Brainfuck.Types.Forward)+| | | | |   minReads=1+| | | | |   mayRaise=[ExceptionFailure]+| | | | |   alwaysRaise=[]+| | | | |   freeRegs=[reg]+| | | | | comment "satisfy ((\\x_0 -> \\x_1 -> x_0) GHC.Types.True)"+| | | | |   minReads=1+| | | | |   mayRaise=[ExceptionFailure]+| | | | |   alwaysRaise=[]+| | | | |   freeRegs=[reg]+| | | | | read (\x_0 -> GHC.Types.True)+| | | | |   minReads=1+| | | | |   mayRaise=[ExceptionFailure]+| | | | |   alwaysRaise=[]+| | | | |   freeRegs=[reg]+| | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| | | | |   minReads=0+| | | | |   mayRaise=[ExceptionFailure]+| | | | |   alwaysRaise=[]+| | | | |   freeRegs=[reg]+| | | | | refJoin join+| | | | |   minReads=0+| | | | |   mayRaise=[ExceptionFailure]+| | | | |   alwaysRaise=[]+| | | | |   freeRegs=[reg]+| | | | <branch (\x_0 -> (\x_1 -> \x_2 -> (GHC.Classes.==) x_1 x_2) '+' x_0)>+| | | | | pushValue (\x_0 -> Parsers.Brainfuck.Types.Increment)+| | | | |   minReads=1+| | | | |   mayRaise=[ExceptionFailure]+| | | | |   alwaysRaise=[]+| | | | |   freeRegs=[reg]+| | | | | comment "satisfy ((\\x_0 -> \\x_1 -> x_0) GHC.Types.True)"+| | | | |   minReads=1+| | | | |   mayRaise=[ExceptionFailure]+| | | | |   alwaysRaise=[]+| | | | |   freeRegs=[reg]+| | | | | read (\x_0 -> GHC.Types.True)+| | | | |   minReads=1+| | | | |   mayRaise=[ExceptionFailure]+| | | | |   alwaysRaise=[]+| | | | |   freeRegs=[reg]+| | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| | | | |   minReads=0+| | | | |   mayRaise=[ExceptionFailure]+| | | | |   alwaysRaise=[]+| | | | |   freeRegs=[reg]+| | | | | refJoin join+| | | | |   minReads=0+| | | | |   mayRaise=[ExceptionFailure]+| | | | |   alwaysRaise=[]+| | | | |   freeRegs=[reg]+| | | | <branch (\x_0 -> (\x_1 -> \x_2 -> (GHC.Classes.==) x_1 x_2) '-' x_0)>+| | | | | pushValue (\x_0 -> Parsers.Brainfuck.Types.Decrement)+| | | | |   minReads=1+| | | | |   mayRaise=[ExceptionFailure]+| | | | |   alwaysRaise=[]+| | | | |   freeRegs=[reg]+| | | | | comment "satisfy ((\\x_0 -> \\x_1 -> x_0) GHC.Types.True)"+| | | | |   minReads=1+| | | | |   mayRaise=[ExceptionFailure]+| | | | |   alwaysRaise=[]+| | | | |   freeRegs=[reg]+| | | | | read (\x_0 -> GHC.Types.True)+| | | | |   minReads=1+| | | | |   mayRaise=[ExceptionFailure]+| | | | |   alwaysRaise=[]+| | | | |   freeRegs=[reg]+| | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| | | | |   minReads=0+| | | | |   mayRaise=[ExceptionFailure]+| | | | |   alwaysRaise=[]+| | | | |   freeRegs=[reg]+| | | | | refJoin join+| | | | |   minReads=0+| | | | |   mayRaise=[ExceptionFailure]+| | | | |   alwaysRaise=[]+| | | | |   freeRegs=[reg]+| | | | <branch (\x_0 -> (\x_1 -> \x_2 -> (GHC.Classes.==) x_1 x_2) ',' x_0)>+| | | | | pushValue (\x_0 -> Parsers.Brainfuck.Types.Input)+| | | | |   minReads=1+| | | | |   mayRaise=[ExceptionFailure]+| | | | |   alwaysRaise=[]+| | | | |   freeRegs=[reg]+| | | | | comment "satisfy ((\\x_0 -> \\x_1 -> x_0) GHC.Types.True)"+| | | | |   minReads=1+| | | | |   mayRaise=[ExceptionFailure]+| | | | |   alwaysRaise=[]+| | | | |   freeRegs=[reg]+| | | | | read (\x_0 -> GHC.Types.True)+| | | | |   minReads=1+| | | | |   mayRaise=[ExceptionFailure]+| | | | |   alwaysRaise=[]+| | | | |   freeRegs=[reg]+| | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| | | | |   minReads=0+| | | | |   mayRaise=[ExceptionFailure]+| | | | |   alwaysRaise=[]+| | | | |   freeRegs=[reg]+| | | | | refJoin join+| | | | |   minReads=0+| | | | |   mayRaise=[ExceptionFailure]+| | | | |   alwaysRaise=[]+| | | | |   freeRegs=[reg]+| | | | <branch (\x_0 -> (\x_1 -> \x_2 -> (GHC.Classes.==) x_1 x_2) '.' x_0)>+| | | | | pushValue (\x_0 -> Parsers.Brainfuck.Types.Output)+| | | | |   minReads=1+| | | | |   mayRaise=[ExceptionFailure]+| | | | |   alwaysRaise=[]+| | | | |   freeRegs=[reg]+| | | | | comment "satisfy ((\\x_0 -> \\x_1 -> x_0) GHC.Types.True)"+| | | | |   minReads=1+| | | | |   mayRaise=[ExceptionFailure]+| | | | |   alwaysRaise=[]+| | | | |   freeRegs=[reg]+| | | | | read (\x_0 -> GHC.Types.True)+| | | | |   minReads=1+| | | | |   mayRaise=[ExceptionFailure]+| | | | |   alwaysRaise=[]+| | | | |   freeRegs=[reg]+| | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| | | | |   minReads=0+| | | | |   mayRaise=[ExceptionFailure]+| | | | |   alwaysRaise=[]+| | | | |   freeRegs=[reg]+| | | | | refJoin join+| | | | |   minReads=0+| | | | |   mayRaise=[ExceptionFailure]+| | | | |   alwaysRaise=[]+| | | | |   freeRegs=[reg]+| | | | <branch (\x_0 -> (\x_1 -> \x_2 -> (GHC.Classes.==) x_1 x_2) '[' x_0)>+| | | | | pushValue (\x_0 -> \x_1 -> \x_2 -> \x_3 -> Parsers.Brainfuck.Types.Loop x_2)+| | | | |   minReads=1+| | | | |   mayRaise=[ExceptionFailure]+| | | | |   alwaysRaise=[]+| | | | |   freeRegs=[]+| | | | | comment "satisfy ((\\x_0 -> \\x_1 -> x_0) GHC.Types.True)"+| | | | |   minReads=1+| | | | |   mayRaise=[ExceptionFailure]+| | | | |   alwaysRaise=[]+| | | | |   freeRegs=[]+| | | | | read (\x_0 -> GHC.Types.True)+| | | | |   minReads=1+| | | | |   mayRaise=[ExceptionFailure]+| | | | |   alwaysRaise=[]+| | | | |   freeRegs=[]+| | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| | | | |   minReads=0+| | | | |   mayRaise=[ExceptionFailure]+| | | | |   alwaysRaise=[]+| | | | |   freeRegs=[]+| | | | | call name+| | | | |   minReads=0+| | | | |   mayRaise=[ExceptionFailure]+| | | | |   alwaysRaise=[]+| | | | |   freeRegs=[]+| | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| | | | |   minReads=0+| | | | |   mayRaise=[]+| | | | |   alwaysRaise=[]+| | | | |   freeRegs=[]+| | | | | call name+| | | | |   minReads=0+| | | | |   mayRaise=[]+| | | | |   alwaysRaise=[]+| | | | |   freeRegs=[]+| | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| | | | |   minReads=1+| | | | |   mayRaise=[ExceptionFailure]+| | | | |   alwaysRaise=[]+| | | | |   freeRegs=[reg]+| | | | | comment "satisfy ((GHC.Classes.==) ']')"+| | | | |   minReads=1+| | | | |   mayRaise=[ExceptionFailure]+| | | | |   alwaysRaise=[]+| | | | |   freeRegs=[reg]+| | | | | read ((GHC.Classes.==) ']')+| | | | |   minReads=1+| | | | |   mayRaise=[ExceptionFailure]+| | | | |   alwaysRaise=[]+| | | | |   freeRegs=[reg]+| | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| | | | |   minReads=0+| | | | |   mayRaise=[ExceptionFailure]+| | | | |   alwaysRaise=[]+| | | | |   freeRegs=[reg]+| | | | | refJoin join+| | | | |   minReads=0+| | | | |   mayRaise=[ExceptionFailure]+| | | | |   alwaysRaise=[]+| | | | |   freeRegs=[reg]+| | | | <default>+| | | | | fail [FailureEmpty]+| | | | |   minReads=0+| | | | |   mayRaise=[ExceptionFailure]+| | | | |   alwaysRaise=[ExceptionFailure]+| | | | |   freeRegs=[]+| | <ko>+| | | comment "raiseAgainIfConsumed"+| | |   minReads=0+| | |   mayRaise=[ExceptionFailure]+| | |   alwaysRaise=[]+| | |   freeRegs=[reg]+| | | saveInput+| | |   minReads=0+| | |   mayRaise=[ExceptionFailure]+| | |   alwaysRaise=[]+| | |   freeRegs=[reg]+| | | lift2Value (\(Data.Text.Internal.Text _ i_0 _) (Data.Text.Internal.Text _+| | |                                                                j_1+| | |                                                                _) -> i_0 GHC.Classes.== j_1)+| | |   minReads=0+| | |   mayRaise=[ExceptionFailure]+| | |   alwaysRaise=[]+| | |   freeRegs=[reg]+| | | choicesBranch+| | |   minReads=0+| | |   mayRaise=[ExceptionFailure]+| | |   alwaysRaise=[]+| | |   freeRegs=[reg]+| | | | <branch (\x_0 -> x_0)>+| | | | | readRegister reg+| | | | |   minReads=0+| | | | |   mayRaise=[]+| | | | |   alwaysRaise=[]+| | | | |   freeRegs=[reg]+| | | | | pushValue GHC.Types.[]+| | | | |   minReads=0+| | | | |   mayRaise=[]+| | | | |   alwaysRaise=[]+| | | | |   freeRegs=[]+| | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| | | | |   minReads=0+| | | | |   mayRaise=[]+| | | | |   alwaysRaise=[]+| | | | |   freeRegs=[]+| | | | | ret+| | | | |   minReads=0+| | | | |   mayRaise=[]+| | | | |   alwaysRaise=[]+| | | | |   freeRegs=[]+| | | | <default>+| | | | | fail []+| | | | |   minReads=0+| | | | |   mayRaise=[ExceptionFailure]+| | | | |   alwaysRaise=[ExceptionFailure]+| | | | |   freeRegs=[]+pushValue (\x_0 -> \x_1 -> GHC.Show.show x_1)+  minReads=0+  mayRaise=[ExceptionFailure]+  alwaysRaise=[]+  freeRegs=[]+call name+  minReads=0+  mayRaise=[ExceptionFailure]+  alwaysRaise=[]+  freeRegs=[]+lift2Value (\x_0 -> \x_1 -> x_0 x_1)+  minReads=0+  mayRaise=[ExceptionFailure]+  alwaysRaise=[]+  freeRegs=[]+call name+  minReads=0+  mayRaise=[ExceptionFailure]+  alwaysRaise=[]+  freeRegs=[]+lift2Value (\x_0 -> \x_1 -> x_0 x_1)+  minReads=0+  mayRaise=[]+  alwaysRaise=[]+  freeRegs=[]+ret+  minReads=0+  mayRaise=[]+  alwaysRaise=[]+  freeRegs=[]
+ tests/Golden/Machine/G14.expected.txt view
@@ -0,0 +1,3649 @@+let name+  minReads=0+  mayRaise=[ExceptionFailure]+  alwaysRaise=[]+  freeRegs=[]+| catch ExceptionFailure+|   minReads=0+|   mayRaise=[ExceptionFailure]+|   alwaysRaise=[]+|   freeRegs=[]+| | <catchScope>+| | | pushValue (\x_0 -> \x_1 -> \x_2 -> GHC.Tuple.())+| | |   minReads=2+| | |   mayRaise=[ExceptionFailure]+| | |   alwaysRaise=[]+| | |   freeRegs=[]+| | | call name+| | |   minReads=2+| | |   mayRaise=[ExceptionFailure]+| | |   alwaysRaise=[]+| | |   freeRegs=[]+| | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| | |   minReads=0+| | |   mayRaise=[ExceptionFailure]+| | |   alwaysRaise=[]+| | |   freeRegs=[]+| | | pushValue (\x_0 -> x_0)+| | |   minReads=0+| | |   mayRaise=[ExceptionFailure]+| | |   alwaysRaise=[]+| | |   freeRegs=[]+| | | newRegister reg+| | |   minReads=0+| | |   mayRaise=[ExceptionFailure]+| | |   alwaysRaise=[]+| | |   freeRegs=[]+| | | iter loop+| | |   minReads=0+| | |   mayRaise=[ExceptionFailure]+| | |   alwaysRaise=[]+| | |   freeRegs=[reg]+| | | | <ok>+| | | | | pushValue (\x_0 -> \x_1 -> \x_2 -> x_0 x_2)+| | | | |   minReads=4+| | | | |   mayRaise=[ExceptionFailure]+| | | | |   alwaysRaise=[]+| | | | |   freeRegs=[reg]+| | | | | call name+| | | | |   minReads=4+| | | | |   mayRaise=[ExceptionFailure]+| | | | |   alwaysRaise=[]+| | | | |   freeRegs=[reg]+| | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| | | | |   minReads=4+| | | | |   mayRaise=[ExceptionFailure]+| | | | |   alwaysRaise=[]+| | | | |   freeRegs=[reg]+| | | | | call name+| | | | |   minReads=4+| | | | |   mayRaise=[ExceptionFailure]+| | | | |   alwaysRaise=[]+| | | | |   freeRegs=[reg]+| | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| | | | |   minReads=2+| | | | |   mayRaise=[ExceptionFailure]+| | | | |   alwaysRaise=[]+| | | | |   freeRegs=[reg]+| | | | | call name+| | | | |   minReads=2+| | | | |   mayRaise=[ExceptionFailure]+| | | | |   alwaysRaise=[]+| | | | |   freeRegs=[reg]+| | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| | | | |   minReads=0+| | | | |   mayRaise=[]+| | | | |   alwaysRaise=[]+| | | | |   freeRegs=[reg]+| | | | | readRegister reg+| | | | |   minReads=0+| | | | |   mayRaise=[]+| | | | |   alwaysRaise=[]+| | | | |   freeRegs=[reg]+| | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| | | | |   minReads=0+| | | | |   mayRaise=[]+| | | | |   alwaysRaise=[]+| | | | |   freeRegs=[reg]+| | | | | writeRegister reg+| | | | |   minReads=0+| | | | |   mayRaise=[]+| | | | |   alwaysRaise=[]+| | | | |   freeRegs=[reg]+| | | | | jump loop+| | | | |   minReads=0+| | | | |   mayRaise=[]+| | | | |   alwaysRaise=[]+| | | | |   freeRegs=[]+| | | | <ko>+| | | | | comment "raiseAgainIfConsumed"+| | | | |   minReads=0+| | | | |   mayRaise=[ExceptionFailure]+| | | | |   alwaysRaise=[]+| | | | |   freeRegs=[reg]+| | | | | saveInput+| | | | |   minReads=0+| | | | |   mayRaise=[ExceptionFailure]+| | | | |   alwaysRaise=[]+| | | | |   freeRegs=[reg]+| | | | | lift2Value (\(Data.Text.Internal.Text _ i_0 _) (Data.Text.Internal.Text _+| | | | |                                                                j_1+| | | | |                                                                _) -> i_0 GHC.Classes.== j_1)+| | | | |   minReads=0+| | | | |   mayRaise=[ExceptionFailure]+| | | | |   alwaysRaise=[]+| | | | |   freeRegs=[reg]+| | | | | choicesBranch+| | | | |   minReads=0+| | | | |   mayRaise=[ExceptionFailure]+| | | | |   alwaysRaise=[]+| | | | |   freeRegs=[reg]+| | | | | | <branch (\x_0 -> x_0)>+| | | | | | | readRegister reg+| | | | | | |   minReads=0+| | | | | | |   mayRaise=[]+| | | | | | |   alwaysRaise=[]+| | | | | | |   freeRegs=[reg]+| | | | | | | call name+| | | | | | |   minReads=0+| | | | | | |   mayRaise=[]+| | | | | | |   alwaysRaise=[]+| | | | | | |   freeRegs=[]+| | | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| | | | | | |   minReads=0+| | | | | | |   mayRaise=[]+| | | | | | |   alwaysRaise=[]+| | | | | | |   freeRegs=[]+| | | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| | | | | | |   minReads=0+| | | | | | |   mayRaise=[]+| | | | | | |   alwaysRaise=[]+| | | | | | |   freeRegs=[]+| | | | | | | call name+| | | | | | |   minReads=0+| | | | | | |   mayRaise=[]+| | | | | | |   alwaysRaise=[]+| | | | | | |   freeRegs=[]+| | | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| | | | | | |   minReads=0+| | | | | | |   mayRaise=[]+| | | | | | |   alwaysRaise=[]+| | | | | | |   freeRegs=[]+| | | | | | | commit ExceptionFailure+| | | | | | |   minReads=0+| | | | | | |   mayRaise=[]+| | | | | | |   alwaysRaise=[]+| | | | | | |   freeRegs=[]+| | | | | | | ret+| | | | | | |   minReads=0+| | | | | | |   mayRaise=[]+| | | | | | |   alwaysRaise=[]+| | | | | | |   freeRegs=[]+| | | | | | <default>+| | | | | | | fail []+| | | | | | |   minReads=0+| | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | |   alwaysRaise=[ExceptionFailure]+| | | | | | |   freeRegs=[]+| | <onException ExceptionFailure>+| | | comment "raiseAgainIfConsumed"+| | |   minReads=0+| | |   mayRaise=[ExceptionFailure]+| | |   alwaysRaise=[]+| | |   freeRegs=[]+| | | saveInput+| | |   minReads=0+| | |   mayRaise=[ExceptionFailure]+| | |   alwaysRaise=[]+| | |   freeRegs=[]+| | | lift2Value (\(Data.Text.Internal.Text _ i_0 _) (Data.Text.Internal.Text _+| | |                                                                j_1+| | |                                                                _) -> i_0 GHC.Classes.== j_1)+| | |   minReads=0+| | |   mayRaise=[ExceptionFailure]+| | |   alwaysRaise=[]+| | |   freeRegs=[]+| | | choicesBranch+| | |   minReads=0+| | |   mayRaise=[ExceptionFailure]+| | |   alwaysRaise=[]+| | |   freeRegs=[]+| | | | <branch (\x_0 -> x_0)>+| | | | | jump name+| | | | |   minReads=0+| | | | |   mayRaise=[]+| | | | |   alwaysRaise=[]+| | | | |   freeRegs=[]+| | | | <default>+| | | | | fail []+| | | | |   minReads=0+| | | | |   mayRaise=[ExceptionFailure]+| | | | |   alwaysRaise=[ExceptionFailure]+| | | | |   freeRegs=[]+let name+  minReads=0+  mayRaise=[]+  alwaysRaise=[]+  freeRegs=[]+| pushValue (\x_0 -> \x_1 -> x_1)+|   minReads=0+|   mayRaise=[]+|   alwaysRaise=[]+|   freeRegs=[]+| ret+|   minReads=0+|   mayRaise=[]+|   alwaysRaise=[]+|   freeRegs=[]+let name+  minReads=0+  mayRaise=[]+  alwaysRaise=[]+  freeRegs=[]+| pushValue GHC.Tuple.()+|   minReads=0+|   mayRaise=[]+|   alwaysRaise=[]+|   freeRegs=[]+| ret+|   minReads=0+|   mayRaise=[]+|   alwaysRaise=[]+|   freeRegs=[]+let name+  minReads=0+  mayRaise=[]+  alwaysRaise=[]+  freeRegs=[]+| pushValue GHC.Tuple.()+|   minReads=0+|   mayRaise=[]+|   alwaysRaise=[]+|   freeRegs=[]+| ret+|   minReads=0+|   mayRaise=[]+|   alwaysRaise=[]+|   freeRegs=[]+let name+  minReads=1+  mayRaise=[ExceptionFailure]+  alwaysRaise=[]+  freeRegs=[]+| comment "satisfy (\\t_0 -> ('0' GHC.Classes.== t_0) GHC.Classes.|| (('1' GHC.Classes.== t_0) GHC.Classes.|| (('2' GHC.Classes.== t_0) GHC.Classes.|| (('3' GHC.Classes.== t_0) GHC.Classes.|| (('4' GHC.Classes.== t_0) GHC.Classes.|| (('5' GHC.Classes.== t_0) GHC.Classes.|| (('6' GHC.Classes.== t_0) GHC.Classes.|| (('7' GHC.Classes.== t_0) GHC.Classes.|| (('8' GHC.Classes.== t_0) GHC.Classes.|| (('9' GHC.Classes.== t_0) GHC.Classes.|| GHC.Types.False))))))))))"+|   minReads=1+|   mayRaise=[ExceptionFailure]+|   alwaysRaise=[]+|   freeRegs=[]+| read (\t_0 -> ('0' GHC.Classes.== t_0) GHC.Classes.|| (('1' GHC.Classes.== t_0) GHC.Classes.|| (('2' GHC.Classes.== t_0) GHC.Classes.|| (('3' GHC.Classes.== t_0) GHC.Classes.|| (('4' GHC.Classes.== t_0) GHC.Classes.|| (('5' GHC.Classes.== t_0) GHC.Classes.|| (('6' GHC.Classes.== t_0) GHC.Classes.|| (('7' GHC.Classes.== t_0) GHC.Classes.|| (('8' GHC.Classes.== t_0) GHC.Classes.|| (('9' GHC.Classes.== t_0) GHC.Classes.|| GHC.Types.False))))))))))+|   minReads=1+|   mayRaise=[ExceptionFailure]+|   alwaysRaise=[]+|   freeRegs=[]+| ret+|   minReads=0+|   mayRaise=[]+|   alwaysRaise=[]+|   freeRegs=[]+let name+  minReads=1+  mayRaise=[ExceptionFailure]+  alwaysRaise=[]+  freeRegs=[]+| pushValue (\x_0 -> \x_1 -> GHC.Tuple.())+|   minReads=1+|   mayRaise=[ExceptionFailure]+|   alwaysRaise=[]+|   freeRegs=[]+| call name+|   minReads=1+|   mayRaise=[ExceptionFailure]+|   alwaysRaise=[]+|   freeRegs=[]+| lift2Value (\x_0 -> \x_1 -> x_0 x_1)+|   minReads=0+|   mayRaise=[ExceptionFailure]+|   alwaysRaise=[]+|   freeRegs=[]+| pushValue (\x_0 -> x_0)+|   minReads=0+|   mayRaise=[ExceptionFailure]+|   alwaysRaise=[]+|   freeRegs=[]+| newRegister reg+|   minReads=0+|   mayRaise=[ExceptionFailure]+|   alwaysRaise=[]+|   freeRegs=[]+| iter loop+|   minReads=0+|   mayRaise=[ExceptionFailure]+|   alwaysRaise=[]+|   freeRegs=[reg]+| | <ok>+| | | pushValue (\x_0 -> \x_1 -> x_1)+| | |   minReads=1+| | |   mayRaise=[ExceptionFailure]+| | |   alwaysRaise=[]+| | |   freeRegs=[reg]+| | | call name+| | |   minReads=1+| | |   mayRaise=[ExceptionFailure]+| | |   alwaysRaise=[]+| | |   freeRegs=[reg]+| | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| | |   minReads=0+| | |   mayRaise=[]+| | |   alwaysRaise=[]+| | |   freeRegs=[reg]+| | | readRegister reg+| | |   minReads=0+| | |   mayRaise=[]+| | |   alwaysRaise=[]+| | |   freeRegs=[reg]+| | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| | |   minReads=0+| | |   mayRaise=[]+| | |   alwaysRaise=[]+| | |   freeRegs=[reg]+| | | writeRegister reg+| | |   minReads=0+| | |   mayRaise=[]+| | |   alwaysRaise=[]+| | |   freeRegs=[reg]+| | | jump loop+| | |   minReads=0+| | |   mayRaise=[]+| | |   alwaysRaise=[]+| | |   freeRegs=[]+| | <ko>+| | | comment "raiseAgainIfConsumed"+| | |   minReads=0+| | |   mayRaise=[ExceptionFailure]+| | |   alwaysRaise=[]+| | |   freeRegs=[reg]+| | | saveInput+| | |   minReads=0+| | |   mayRaise=[ExceptionFailure]+| | |   alwaysRaise=[]+| | |   freeRegs=[reg]+| | | lift2Value (\(Data.Text.Internal.Text _ i_0 _) (Data.Text.Internal.Text _+| | |                                                                j_1+| | |                                                                _) -> i_0 GHC.Classes.== j_1)+| | |   minReads=0+| | |   mayRaise=[ExceptionFailure]+| | |   alwaysRaise=[]+| | |   freeRegs=[reg]+| | | choicesBranch+| | |   minReads=0+| | |   mayRaise=[ExceptionFailure]+| | |   alwaysRaise=[]+| | |   freeRegs=[reg]+| | | | <branch (\x_0 -> x_0)>+| | | | | readRegister reg+| | | | |   minReads=0+| | | | |   mayRaise=[]+| | | | |   alwaysRaise=[]+| | | | |   freeRegs=[reg]+| | | | | pushValue GHC.Tuple.()+| | | | |   minReads=0+| | | | |   mayRaise=[]+| | | | |   alwaysRaise=[]+| | | | |   freeRegs=[]+| | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| | | | |   minReads=0+| | | | |   mayRaise=[]+| | | | |   alwaysRaise=[]+| | | | |   freeRegs=[]+| | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| | | | |   minReads=0+| | | | |   mayRaise=[]+| | | | |   alwaysRaise=[]+| | | | |   freeRegs=[]+| | | | | ret+| | | | |   minReads=0+| | | | |   mayRaise=[]+| | | | |   alwaysRaise=[]+| | | | |   freeRegs=[]+| | | | <default>+| | | | | fail []+| | | | |   minReads=0+| | | | |   mayRaise=[ExceptionFailure]+| | | | |   alwaysRaise=[ExceptionFailure]+| | | | |   freeRegs=[]+let name+  minReads=1+  mayRaise=[ExceptionFailure]+  alwaysRaise=[]+  freeRegs=[]+| pushValue (\x_0 -> \x_1 -> x_1)+|   minReads=1+|   mayRaise=[ExceptionFailure]+|   alwaysRaise=[]+|   freeRegs=[]+| comment "satisfy GHC.Unicode.isSpace"+|   minReads=1+|   mayRaise=[ExceptionFailure]+|   alwaysRaise=[]+|   freeRegs=[]+| read GHC.Unicode.isSpace+|   minReads=1+|   mayRaise=[ExceptionFailure]+|   alwaysRaise=[]+|   freeRegs=[]+| lift2Value (\x_0 -> \x_1 -> x_0 x_1)+|   minReads=0+|   mayRaise=[]+|   alwaysRaise=[]+|   freeRegs=[]+| call name+|   minReads=0+|   mayRaise=[]+|   alwaysRaise=[]+|   freeRegs=[]+| lift2Value (\x_0 -> \x_1 -> x_0 x_1)+|   minReads=0+|   mayRaise=[]+|   alwaysRaise=[]+|   freeRegs=[]+| ret+|   minReads=0+|   mayRaise=[]+|   alwaysRaise=[]+|   freeRegs=[]+let name+  minReads=2+  mayRaise=[ExceptionFailure]+  alwaysRaise=[]+  freeRegs=[]+| catch ExceptionFailure+|   minReads=2+|   mayRaise=[ExceptionFailure]+|   alwaysRaise=[]+|   freeRegs=[]+| | <catchScope>+| | | pushValue (\x_0 -> \x_1 -> x_1)+| | |   minReads=2+| | |   mayRaise=[ExceptionFailure]+| | |   alwaysRaise=[]+| | |   freeRegs=[]+| | | join join+| | |   minReads=1+| | |   mayRaise=[ExceptionFailure]+| | |   alwaysRaise=[]+| | |   freeRegs=[]+| | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| | | |   minReads=1+| | | |   mayRaise=[ExceptionFailure]+| | | |   alwaysRaise=[]+| | | |   freeRegs=[]+| | | | call name+| | | |   minReads=1+| | | |   mayRaise=[ExceptionFailure]+| | | |   alwaysRaise=[]+| | | |   freeRegs=[]+| | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| | | |   minReads=0+| | | |   mayRaise=[]+| | | |   alwaysRaise=[]+| | | |   freeRegs=[]+| | | | commit ExceptionFailure+| | | |   minReads=0+| | | |   mayRaise=[]+| | | |   alwaysRaise=[]+| | | |   freeRegs=[]+| | | | ret+| | | |   minReads=0+| | | |   mayRaise=[]+| | | |   alwaysRaise=[]+| | | |   freeRegs=[]+| | | catch ExceptionFailure+| | |   minReads=2+| | |   mayRaise=[ExceptionFailure]+| | |   alwaysRaise=[]+| | |   freeRegs=[]+| | | | <catchScope>+| | | | | pushValue (\x_0 -> '0')+| | | | |   minReads=2+| | | | |   mayRaise=[ExceptionFailure]+| | | | |   alwaysRaise=[]+| | | | |   freeRegs=[]+| | | | | comment "satisfy ((GHC.Classes.==) '0')"+| | | | |   minReads=2+| | | | |   mayRaise=[ExceptionFailure]+| | | | |   alwaysRaise=[]+| | | | |   freeRegs=[]+| | | | | read ((GHC.Classes.==) '0')+| | | | |   minReads=2+| | | | |   mayRaise=[ExceptionFailure]+| | | | |   alwaysRaise=[]+| | | | |   freeRegs=[]+| | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| | | | |   minReads=1+| | | | |   mayRaise=[ExceptionFailure]+| | | | |   alwaysRaise=[]+| | | | |   freeRegs=[]+| | | | | commit ExceptionFailure+| | | | |   minReads=1+| | | | |   mayRaise=[ExceptionFailure]+| | | | |   alwaysRaise=[]+| | | | |   freeRegs=[]+| | | | | refJoin join+| | | | |   minReads=1+| | | | |   mayRaise=[ExceptionFailure]+| | | | |   alwaysRaise=[]+| | | | |   freeRegs=[]+| | | | <onException ExceptionFailure>+| | | | | comment "raiseAgainIfConsumed"+| | | | |   minReads=2+| | | | |   mayRaise=[ExceptionFailure]+| | | | |   alwaysRaise=[]+| | | | |   freeRegs=[]+| | | | | saveInput+| | | | |   minReads=2+| | | | |   mayRaise=[ExceptionFailure]+| | | | |   alwaysRaise=[]+| | | | |   freeRegs=[]+| | | | | lift2Value (\(Data.Text.Internal.Text _ i_0 _) (Data.Text.Internal.Text _+| | | | |                                                                j_1+| | | | |                                                                _) -> i_0 GHC.Classes.== j_1)+| | | | |   minReads=2+| | | | |   mayRaise=[ExceptionFailure]+| | | | |   alwaysRaise=[]+| | | | |   freeRegs=[]+| | | | | choicesBranch+| | | | |   minReads=2+| | | | |   mayRaise=[ExceptionFailure]+| | | | |   alwaysRaise=[]+| | | | |   freeRegs=[]+| | | | | | <branch (\x_0 -> x_0)>+| | | | | | | pushValue (\x_0 -> '1')+| | | | | | |   minReads=2+| | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | |   alwaysRaise=[]+| | | | | | |   freeRegs=[]+| | | | | | | comment "satisfy ((GHC.Classes.==) '1')"+| | | | | | |   minReads=2+| | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | |   alwaysRaise=[]+| | | | | | |   freeRegs=[]+| | | | | | | read ((GHC.Classes.==) '1')+| | | | | | |   minReads=2+| | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | |   alwaysRaise=[]+| | | | | | |   freeRegs=[]+| | | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| | | | | | |   minReads=1+| | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | |   alwaysRaise=[]+| | | | | | |   freeRegs=[]+| | | | | | | refJoin join+| | | | | | |   minReads=1+| | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | |   alwaysRaise=[]+| | | | | | |   freeRegs=[]+| | | | | | <default>+| | | | | | | fail []+| | | | | | |   minReads=0+| | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | |   alwaysRaise=[ExceptionFailure]+| | | | | | |   freeRegs=[]+| | <onException ExceptionFailure>+| | | comment "raiseAgainIfConsumed"+| | |   minReads=2+| | |   mayRaise=[ExceptionFailure]+| | |   alwaysRaise=[]+| | |   freeRegs=[]+| | | saveInput+| | |   minReads=2+| | |   mayRaise=[ExceptionFailure]+| | |   alwaysRaise=[]+| | |   freeRegs=[]+| | | lift2Value (\(Data.Text.Internal.Text _ i_0 _) (Data.Text.Internal.Text _+| | |                                                                j_1+| | |                                                                _) -> i_0 GHC.Classes.== j_1)+| | |   minReads=2+| | |   mayRaise=[ExceptionFailure]+| | |   alwaysRaise=[]+| | |   freeRegs=[]+| | | choicesBranch+| | |   minReads=2+| | |   mayRaise=[ExceptionFailure]+| | |   alwaysRaise=[]+| | |   freeRegs=[]+| | | | <branch (\x_0 -> x_0)>+| | | | | catch ExceptionFailure+| | | | |   minReads=2+| | | | |   mayRaise=[ExceptionFailure]+| | | | |   alwaysRaise=[]+| | | | |   freeRegs=[]+| | | | | | <catchScope>+| | | | | | | pushValue (\x_0 -> \x_1 -> \x_2 -> \x_3 -> x_1)+| | | | | | |   minReads=4+| | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | |   alwaysRaise=[]+| | | | | | |   freeRegs=[]+| | | | | | | comment "satisfy ((GHC.Classes.==) '\\'')"+| | | | | | |   minReads=4+| | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | |   alwaysRaise=[]+| | | | | | |   freeRegs=[]+| | | | | | | read ((GHC.Classes.==) '\'')+| | | | | | |   minReads=4+| | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | |   alwaysRaise=[]+| | | | | | |   freeRegs=[]+| | | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| | | | | | |   minReads=3+| | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | |   alwaysRaise=[]+| | | | | | |   freeRegs=[]+| | | | | | | join join+| | | | | | |   minReads=2+| | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | |   alwaysRaise=[]+| | | | | | |   freeRegs=[]+| | | | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| | | | | | | |   minReads=2+| | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | |   alwaysRaise=[]+| | | | | | | |   freeRegs=[]+| | | | | | | | comment "satisfy ((GHC.Classes.==) '\\'')"+| | | | | | | |   minReads=2+| | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | |   alwaysRaise=[]+| | | | | | | |   freeRegs=[]+| | | | | | | | read ((GHC.Classes.==) '\'')+| | | | | | | |   minReads=2+| | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | |   alwaysRaise=[]+| | | | | | | |   freeRegs=[]+| | | | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| | | | | | | |   minReads=1+| | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | |   alwaysRaise=[]+| | | | | | | |   freeRegs=[]+| | | | | | | | call name+| | | | | | | |   minReads=1+| | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | |   alwaysRaise=[]+| | | | | | | |   freeRegs=[]+| | | | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| | | | | | | |   minReads=0+| | | | | | | |   mayRaise=[]+| | | | | | | |   alwaysRaise=[]+| | | | | | | |   freeRegs=[]+| | | | | | | | commit ExceptionFailure+| | | | | | | |   minReads=0+| | | | | | | |   mayRaise=[]+| | | | | | | |   alwaysRaise=[]+| | | | | | | |   freeRegs=[]+| | | | | | | | ret+| | | | | | | |   minReads=0+| | | | | | | |   mayRaise=[]+| | | | | | | |   alwaysRaise=[]+| | | | | | | |   freeRegs=[]+| | | | | | | catch ExceptionFailure+| | | | | | |   minReads=3+| | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | |   alwaysRaise=[]+| | | | | | |   freeRegs=[]+| | | | | | | | <catchScope>+| | | | | | | | | pushValue (\x_0 -> \x_1 -> x_1)+| | | | | | | | |   minReads=3+| | | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | | |   alwaysRaise=[]+| | | | | | | | |   freeRegs=[]+| | | | | | | | | comment "satisfy Parsers.Nandlang.nandStringLetter"+| | | | | | | | |   minReads=3+| | | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | | |   alwaysRaise=[]+| | | | | | | | |   freeRegs=[]+| | | | | | | | | read Parsers.Nandlang.nandStringLetter+| | | | | | | | |   minReads=3+| | | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | | |   alwaysRaise=[]+| | | | | | | | |   freeRegs=[]+| | | | | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| | | | | | | | |   minReads=2+| | | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | | |   alwaysRaise=[]+| | | | | | | | |   freeRegs=[]+| | | | | | | | | call name+| | | | | | | | |   minReads=2+| | | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | | |   alwaysRaise=[]+| | | | | | | | |   freeRegs=[]+| | | | | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| | | | | | | | |   minReads=2+| | | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | | |   alwaysRaise=[]+| | | | | | | | |   freeRegs=[]+| | | | | | | | | commit ExceptionFailure+| | | | | | | | |   minReads=2+| | | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | | |   alwaysRaise=[]+| | | | | | | | |   freeRegs=[]+| | | | | | | | | refJoin join+| | | | | | | | |   minReads=2+| | | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | | |   alwaysRaise=[]+| | | | | | | | |   freeRegs=[]+| | | | | | | | <onException ExceptionFailure>+| | | | | | | | | comment "raiseAgainIfConsumed"+| | | | | | | | |   minReads=4+| | | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | | |   alwaysRaise=[]+| | | | | | | | |   freeRegs=[]+| | | | | | | | | saveInput+| | | | | | | | |   minReads=4+| | | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | | |   alwaysRaise=[]+| | | | | | | | |   freeRegs=[]+| | | | | | | | | lift2Value (\(Data.Text.Internal.Text _ i_0 _) (Data.Text.Internal.Text _+| | | | | | | | |                                                                j_1+| | | | | | | | |                                                                _) -> i_0 GHC.Classes.== j_1)+| | | | | | | | |   minReads=4+| | | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | | |   alwaysRaise=[]+| | | | | | | | |   freeRegs=[]+| | | | | | | | | choicesBranch+| | | | | | | | |   minReads=4+| | | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | | |   alwaysRaise=[]+| | | | | | | | |   freeRegs=[]+| | | | | | | | | | <branch (\x_0 -> x_0)>+| | | | | | | | | | | pushValue (\x_0 -> \x_1 -> \x_2 -> x_2)+| | | | | | | | | | |   minReads=4+| | | | | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | | | | |   alwaysRaise=[]+| | | | | | | | | | |   freeRegs=[]+| | | | | | | | | | | comment "satisfy ((GHC.Classes.==) '\\\\')"+| | | | | | | | | | |   minReads=4+| | | | | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | | | | |   alwaysRaise=[]+| | | | | | | | | | |   freeRegs=[]+| | | | | | | | | | | read ((GHC.Classes.==) '\\')+| | | | | | | | | | |   minReads=4+| | | | | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | | | | |   alwaysRaise=[]+| | | | | | | | | | |   freeRegs=[]+| | | | | | | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| | | | | | | | | | |   minReads=3+| | | | | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | | | | |   alwaysRaise=[]+| | | | | | | | | | |   freeRegs=[]+| | | | | | | | | | | comment "satisfy (\\t_0 -> ('0' GHC.Classes.== t_0) GHC.Classes.|| (('t' GHC.Classes.== t_0) GHC.Classes.|| (('n' GHC.Classes.== t_0) GHC.Classes.|| (('v' GHC.Classes.== t_0) GHC.Classes.|| (('f' GHC.Classes.== t_0) GHC.Classes.|| (('r' GHC.Classes.== t_0) GHC.Classes.|| GHC.Types.False))))))"+| | | | | | | | | | |   minReads=3+| | | | | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | | | | |   alwaysRaise=[]+| | | | | | | | | | |   freeRegs=[]+| | | | | | | | | | | read (\t_0 -> ('0' GHC.Classes.== t_0) GHC.Classes.|| (('t' GHC.Classes.== t_0) GHC.Classes.|| (('n' GHC.Classes.== t_0) GHC.Classes.|| (('v' GHC.Classes.== t_0) GHC.Classes.|| (('f' GHC.Classes.== t_0) GHC.Classes.|| (('r' GHC.Classes.== t_0) GHC.Classes.|| GHC.Types.False))))))+| | | | | | | | | | |   minReads=3+| | | | | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | | | | |   alwaysRaise=[]+| | | | | | | | | | |   freeRegs=[]+| | | | | | | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| | | | | | | | | | |   minReads=2+| | | | | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | | | | |   alwaysRaise=[]+| | | | | | | | | | |   freeRegs=[]+| | | | | | | | | | | call name+| | | | | | | | | | |   minReads=2+| | | | | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | | | | |   alwaysRaise=[]+| | | | | | | | | | |   freeRegs=[]+| | | | | | | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| | | | | | | | | | |   minReads=2+| | | | | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | | | | |   alwaysRaise=[]+| | | | | | | | | | |   freeRegs=[]+| | | | | | | | | | | refJoin join+| | | | | | | | | | |   minReads=2+| | | | | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | | | | |   alwaysRaise=[]+| | | | | | | | | | |   freeRegs=[]+| | | | | | | | | | <default>+| | | | | | | | | | | fail []+| | | | | | | | | | |   minReads=0+| | | | | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | | | | |   alwaysRaise=[ExceptionFailure]+| | | | | | | | | | |   freeRegs=[]+| | | | | | <onException ExceptionFailure>+| | | | | | | comment "raiseAgainIfConsumed"+| | | | | | |   minReads=2+| | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | |   alwaysRaise=[]+| | | | | | |   freeRegs=[]+| | | | | | | saveInput+| | | | | | |   minReads=2+| | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | |   alwaysRaise=[]+| | | | | | |   freeRegs=[]+| | | | | | | lift2Value (\(Data.Text.Internal.Text _ i_0 _) (Data.Text.Internal.Text _+| | | | | | |                                                                j_1+| | | | | | |                                                                _) -> i_0 GHC.Classes.== j_1)+| | | | | | |   minReads=2+| | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | |   alwaysRaise=[]+| | | | | | |   freeRegs=[]+| | | | | | | choicesBranch+| | | | | | |   minReads=2+| | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | |   alwaysRaise=[]+| | | | | | |   freeRegs=[]+| | | | | | | | <branch (\x_0 -> x_0)>+| | | | | | | | | pushValue (\x_0 -> \x_1 -> x_1)+| | | | | | | | |   minReads=2+| | | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | | |   alwaysRaise=[]+| | | | | | | | |   freeRegs=[]+| | | | | | | | | call name+| | | | | | | | |   minReads=2+| | | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | | |   alwaysRaise=[]+| | | | | | | | |   freeRegs=[]+| | | | | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| | | | | | | | |   minReads=0+| | | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | | |   alwaysRaise=[]+| | | | | | | | |   freeRegs=[]+| | | | | | | | | join join+| | | | | | | | |   minReads=0+| | | | | | | | |   mayRaise=[]+| | | | | | | | |   alwaysRaise=[]+| | | | | | | | |   freeRegs=[]+| | | | | | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| | | | | | | | | |   minReads=0+| | | | | | | | | |   mayRaise=[]+| | | | | | | | | |   alwaysRaise=[]+| | | | | | | | | |   freeRegs=[]+| | | | | | | | | | ret+| | | | | | | | | |   minReads=0+| | | | | | | | | |   mayRaise=[]+| | | | | | | | | |   alwaysRaise=[]+| | | | | | | | | |   freeRegs=[]+| | | | | | | | | catch ExceptionFailure+| | | | | | | | |   minReads=0+| | | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | | |   alwaysRaise=[]+| | | | | | | | |   freeRegs=[]+| | | | | | | | | | <catchScope>+| | | | | | | | | | | pushValue (\x_0 -> GHC.Tuple.())+| | | | | | | | | | |   minReads=2+| | | | | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | | | | |   alwaysRaise=[]+| | | | | | | | | | |   freeRegs=[]+| | | | | | | | | | | join join+| | | | | | | | | | |   minReads=0+| | | | | | | | | | |   mayRaise=[]+| | | | | | | | | | |   alwaysRaise=[]+| | | | | | | | | | |   freeRegs=[]+| | | | | | | | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| | | | | | | | | | | |   minReads=0+| | | | | | | | | | | |   mayRaise=[]+| | | | | | | | | | | |   alwaysRaise=[]+| | | | | | | | | | | |   freeRegs=[]+| | | | | | | | | | | | commit ExceptionFailure+| | | | | | | | | | | |   minReads=0+| | | | | | | | | | | |   mayRaise=[]+| | | | | | | | | | | |   alwaysRaise=[]+| | | | | | | | | | | |   freeRegs=[]+| | | | | | | | | | | | refJoin join+| | | | | | | | | | | |   minReads=0+| | | | | | | | | | | |   mayRaise=[]+| | | | | | | | | | | |   alwaysRaise=[]+| | | | | | | | | | | |   freeRegs=[]+| | | | | | | | | | | catch ExceptionFailure+| | | | | | | | | | |   minReads=2+| | | | | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | | | | |   alwaysRaise=[]+| | | | | | | | | | |   freeRegs=[]+| | | | | | | | | | | | <catchScope>+| | | | | | | | | | | | | pushValue (\x_0 -> \x_1 -> \x_2 -> x_1)+| | | | | | | | | | | | |   minReads=2+| | | | | | | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | | | | | | |   alwaysRaise=[]+| | | | | | | | | | | | |   freeRegs=[]+| | | | | | | | | | | | | call name+| | | | | | | | | | | | |   minReads=2+| | | | | | | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | | | | | | |   alwaysRaise=[]+| | | | | | | | | | | | |   freeRegs=[]+| | | | | | | | | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| | | | | | | | | | | | |   minReads=0+| | | | | | | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | | | | | | |   alwaysRaise=[]+| | | | | | | | | | | | |   freeRegs=[]+| | | | | | | | | | | | | join join+| | | | | | | | | | | | |   minReads=2+| | | | | | | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | | | | | | |   alwaysRaise=[]+| | | | | | | | | | | | |   freeRegs=[]+| | | | | | | | | | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| | | | | | | | | | | | | |   minReads=2+| | | | | | | | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | | | | | | | |   alwaysRaise=[]+| | | | | | | | | | | | | |   freeRegs=[]+| | | | | | | | | | | | | | call name+| | | | | | | | | | | | | |   minReads=2+| | | | | | | | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | | | | | | | |   alwaysRaise=[]+| | | | | | | | | | | | | |   freeRegs=[]+| | | | | | | | | | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| | | | | | | | | | | | | |   minReads=0+| | | | | | | | | | | | | |   mayRaise=[]+| | | | | | | | | | | | | |   alwaysRaise=[]+| | | | | | | | | | | | | |   freeRegs=[]+| | | | | | | | | | | | | | commit ExceptionFailure+| | | | | | | | | | | | | |   minReads=0+| | | | | | | | | | | | | |   mayRaise=[]+| | | | | | | | | | | | | |   alwaysRaise=[]+| | | | | | | | | | | | | |   freeRegs=[]+| | | | | | | | | | | | | | refJoin join+| | | | | | | | | | | | | |   minReads=0+| | | | | | | | | | | | | |   mayRaise=[]+| | | | | | | | | | | | | |   alwaysRaise=[]+| | | | | | | | | | | | | |   freeRegs=[]+| | | | | | | | | | | | | catch ExceptionFailure+| | | | | | | | | | | | |   minReads=0+| | | | | | | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | | | | | | |   alwaysRaise=[]+| | | | | | | | | | | | |   freeRegs=[]+| | | | | | | | | | | | | | <catchScope>+| | | | | | | | | | | | | | | pushValue (\x_0 -> \x_1 -> \x_2 -> GHC.Tuple.())+| | | | | | | | | | | | | | |   minReads=0+| | | | | | | | | | | | | | |   mayRaise=[]+| | | | | | | | | | | | | | |   alwaysRaise=[]+| | | | | | | | | | | | | | |   freeRegs=[]+| | | | | | | | | | | | | | | call name+| | | | | | | | | | | | | | |   minReads=0+| | | | | | | | | | | | | | |   mayRaise=[]+| | | | | | | | | | | | | | |   alwaysRaise=[]+| | | | | | | | | | | | | | |   freeRegs=[]+| | | | | | | | | | | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| | | | | | | | | | | | | | |   minReads=2+| | | | | | | | | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | | | | | | | | |   alwaysRaise=[]+| | | | | | | | | | | | | | |   freeRegs=[]+| | | | | | | | | | | | | | | pushValue (\x_0 -> x_0)+| | | | | | | | | | | | | | |   minReads=2+| | | | | | | | | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | | | | | | | | |   alwaysRaise=[]+| | | | | | | | | | | | | | |   freeRegs=[]+| | | | | | | | | | | | | | | newRegister reg+| | | | | | | | | | | | | | |   minReads=2+| | | | | | | | | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | | | | | | | | |   alwaysRaise=[]+| | | | | | | | | | | | | | |   freeRegs=[]+| | | | | | | | | | | | | | | iter loop+| | | | | | | | | | | | | | |   minReads=2+| | | | | | | | | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | | | | | | | | |   alwaysRaise=[]+| | | | | | | | | | | | | | |   freeRegs=[reg]+| | | | | | | | | | | | | | | | <ok>+| | | | | | | | | | | | | | | | | pushValue (\x_0 -> \x_1 -> \x_2 -> x_0 x_2)+| | | | | | | | | | | | | | | | |   minReads=2+| | | | | | | | | | | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | | | | | | | | | | |   alwaysRaise=[]+| | | | | | | | | | | | | | | | |   freeRegs=[]+| | | | | | | | | | | | | | | | | call name+| | | | | | | | | | | | | | | | |   minReads=2+| | | | | | | | | | | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | | | | | | | | | | |   alwaysRaise=[]+| | | | | | | | | | | | | | | | |   freeRegs=[]+| | | | | | | | | | | | | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| | | | | | | | | | | | | | | | |   minReads=2+| | | | | | | | | | | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | | | | | | | | | | |   alwaysRaise=[]+| | | | | | | | | | | | | | | | |   freeRegs=[]+| | | | | | | | | | | | | | | | | call name+| | | | | | | | | | | | | | | | |   minReads=2+| | | | | | | | | | | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | | | | | | | | | | |   alwaysRaise=[]+| | | | | | | | | | | | | | | | |   freeRegs=[]+| | | | | | | | | | | | | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| | | | | | | | | | | | | | | | |   minReads=0+| | | | | | | | | | | | | | | | |   mayRaise=[]+| | | | | | | | | | | | | | | | |   alwaysRaise=[]+| | | | | | | | | | | | | | | | |   freeRegs=[]+| | | | | | | | | | | | | | | | | call name+| | | | | | | | | | | | | | | | |   minReads=0+| | | | | | | | | | | | | | | | |   mayRaise=[]+| | | | | | | | | | | | | | | | |   alwaysRaise=[]+| | | | | | | | | | | | | | | | |   freeRegs=[]+| | | | | | | | | | | | | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| | | | | | | | | | | | | | | | |   minReads=0+| | | | | | | | | | | | | | | | |   mayRaise=[]+| | | | | | | | | | | | | | | | |   alwaysRaise=[]+| | | | | | | | | | | | | | | | |   freeRegs=[reg]+| | | | | | | | | | | | | | | | | readRegister reg+| | | | | | | | | | | | | | | | |   minReads=0+| | | | | | | | | | | | | | | | |   mayRaise=[]+| | | | | | | | | | | | | | | | |   alwaysRaise=[]+| | | | | | | | | | | | | | | | |   freeRegs=[reg]+| | | | | | | | | | | | | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| | | | | | | | | | | | | | | | |   minReads=0+| | | | | | | | | | | | | | | | |   mayRaise=[]+| | | | | | | | | | | | | | | | |   alwaysRaise=[]+| | | | | | | | | | | | | | | | |   freeRegs=[reg]+| | | | | | | | | | | | | | | | | writeRegister reg+| | | | | | | | | | | | | | | | |   minReads=0+| | | | | | | | | | | | | | | | |   mayRaise=[]+| | | | | | | | | | | | | | | | |   alwaysRaise=[]+| | | | | | | | | | | | | | | | |   freeRegs=[reg]+| | | | | | | | | | | | | | | | | jump loop+| | | | | | | | | | | | | | | | |   minReads=0+| | | | | | | | | | | | | | | | |   mayRaise=[]+| | | | | | | | | | | | | | | | |   alwaysRaise=[]+| | | | | | | | | | | | | | | | |   freeRegs=[]+| | | | | | | | | | | | | | | | <ko>+| | | | | | | | | | | | | | | | | comment "raiseAgainIfConsumed"+| | | | | | | | | | | | | | | | |   minReads=2+| | | | | | | | | | | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | | | | | | | | | | |   alwaysRaise=[]+| | | | | | | | | | | | | | | | |   freeRegs=[reg]+| | | | | | | | | | | | | | | | | saveInput+| | | | | | | | | | | | | | | | |   minReads=2+| | | | | | | | | | | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | | | | | | | | | | |   alwaysRaise=[]+| | | | | | | | | | | | | | | | |   freeRegs=[reg]+| | | | | | | | | | | | | | | | | lift2Value (\(Data.Text.Internal.Text _ i_0 _) (Data.Text.Internal.Text _+| | | | | | | | | | | | | | | | |                                                                j_1+| | | | | | | | | | | | | | | | |                                                                _) -> i_0 GHC.Classes.== j_1)+| | | | | | | | | | | | | | | | |   minReads=2+| | | | | | | | | | | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | | | | | | | | | | |   alwaysRaise=[]+| | | | | | | | | | | | | | | | |   freeRegs=[reg]+| | | | | | | | | | | | | | | | | choicesBranch+| | | | | | | | | | | | | | | | |   minReads=2+| | | | | | | | | | | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | | | | | | | | | | |   alwaysRaise=[]+| | | | | | | | | | | | | | | | |   freeRegs=[reg]+| | | | | | | | | | | | | | | | | | <branch (\x_0 -> x_0)>+| | | | | | | | | | | | | | | | | | | readRegister reg+| | | | | | | | | | | | | | | | | | |   minReads=2+| | | | | | | | | | | | | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | | | | | | | | | | | | |   alwaysRaise=[]+| | | | | | | | | | | | | | | | | | |   freeRegs=[reg]+| | | | | | | | | | | | | | | | | | | call name+| | | | | | | | | | | | | | | | | | |   minReads=2+| | | | | | | | | | | | | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | | | | | | | | | | | | |   alwaysRaise=[]+| | | | | | | | | | | | | | | | | | |   freeRegs=[]+| | | | | | | | | | | | | | | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| | | | | | | | | | | | | | | | | | |   minReads=2+| | | | | | | | | | | | | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | | | | | | | | | | | | |   alwaysRaise=[]+| | | | | | | | | | | | | | | | | | |   freeRegs=[]+| | | | | | | | | | | | | | | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| | | | | | | | | | | | | | | | | | |   minReads=2+| | | | | | | | | | | | | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | | | | | | | | | | | | |   alwaysRaise=[]+| | | | | | | | | | | | | | | | | | |   freeRegs=[]+| | | | | | | | | | | | | | | | | | | call name+| | | | | | | | | | | | | | | | | | |   minReads=2+| | | | | | | | | | | | | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | | | | | | | | | | | | |   alwaysRaise=[]+| | | | | | | | | | | | | | | | | | |   freeRegs=[]+| | | | | | | | | | | | | | | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| | | | | | | | | | | | | | | | | | |   minReads=2+| | | | | | | | | | | | | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | | | | | | | | | | | | |   alwaysRaise=[]+| | | | | | | | | | | | | | | | | | |   freeRegs=[]+| | | | | | | | | | | | | | | | | | | commit ExceptionFailure+| | | | | | | | | | | | | | | | | | |   minReads=2+| | | | | | | | | | | | | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | | | | | | | | | | | | |   alwaysRaise=[]+| | | | | | | | | | | | | | | | | | |   freeRegs=[]+| | | | | | | | | | | | | | | | | | | refJoin join+| | | | | | | | | | | | | | | | | | |   minReads=2+| | | | | | | | | | | | | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | | | | | | | | | | | | |   alwaysRaise=[]+| | | | | | | | | | | | | | | | | | |   freeRegs=[]+| | | | | | | | | | | | | | | | | | <default>+| | | | | | | | | | | | | | | | | | | fail []+| | | | | | | | | | | | | | | | | | |   minReads=0+| | | | | | | | | | | | | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | | | | | | | | | | | | |   alwaysRaise=[ExceptionFailure]+| | | | | | | | | | | | | | | | | | |   freeRegs=[]+| | | | | | | | | | | | | | <onException ExceptionFailure>+| | | | | | | | | | | | | | | comment "raiseAgainIfConsumed"+| | | | | | | | | | | | | | |   minReads=2+| | | | | | | | | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | | | | | | | | |   alwaysRaise=[]+| | | | | | | | | | | | | | |   freeRegs=[]+| | | | | | | | | | | | | | | saveInput+| | | | | | | | | | | | | | |   minReads=2+| | | | | | | | | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | | | | | | | | |   alwaysRaise=[]+| | | | | | | | | | | | | | |   freeRegs=[]+| | | | | | | | | | | | | | | lift2Value (\(Data.Text.Internal.Text _ i_0 _) (Data.Text.Internal.Text _+| | | | | | | | | | | | | | |                                                                j_1+| | | | | | | | | | | | | | |                                                                _) -> i_0 GHC.Classes.== j_1)+| | | | | | | | | | | | | | |   minReads=2+| | | | | | | | | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | | | | | | | | |   alwaysRaise=[]+| | | | | | | | | | | | | | |   freeRegs=[]+| | | | | | | | | | | | | | | choicesBranch+| | | | | | | | | | | | | | |   minReads=2+| | | | | | | | | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | | | | | | | | |   alwaysRaise=[]+| | | | | | | | | | | | | | |   freeRegs=[]+| | | | | | | | | | | | | | | | <branch (\x_0 -> x_0)>+| | | | | | | | | | | | | | | | | call name+| | | | | | | | | | | | | | | | |   minReads=2+| | | | | | | | | | | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | | | | | | | | | | |   alwaysRaise=[]+| | | | | | | | | | | | | | | | |   freeRegs=[]+| | | | | | | | | | | | | | | | | refJoin join+| | | | | | | | | | | | | | | | |   minReads=2+| | | | | | | | | | | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | | | | | | | | | | |   alwaysRaise=[]+| | | | | | | | | | | | | | | | |   freeRegs=[]+| | | | | | | | | | | | | | | | <default>+| | | | | | | | | | | | | | | | | fail []+| | | | | | | | | | | | | | | | |   minReads=0+| | | | | | | | | | | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | | | | | | | | | | |   alwaysRaise=[ExceptionFailure]+| | | | | | | | | | | | | | | | |   freeRegs=[]+| | | | | | | | | | | | <onException ExceptionFailure>+| | | | | | | | | | | | | comment "raiseAgainIfConsumed"+| | | | | | | | | | | | |   minReads=5+| | | | | | | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | | | | | | |   alwaysRaise=[]+| | | | | | | | | | | | |   freeRegs=[]+| | | | | | | | | | | | | saveInput+| | | | | | | | | | | | |   minReads=5+| | | | | | | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | | | | | | |   alwaysRaise=[]+| | | | | | | | | | | | |   freeRegs=[]+| | | | | | | | | | | | | lift2Value (\(Data.Text.Internal.Text _ i_0 _) (Data.Text.Internal.Text _+| | | | | | | | | | | | |                                                                j_1+| | | | | | | | | | | | |                                                                _) -> i_0 GHC.Classes.== j_1)+| | | | | | | | | | | | |   minReads=5+| | | | | | | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | | | | | | |   alwaysRaise=[]+| | | | | | | | | | | | |   freeRegs=[]+| | | | | | | | | | | | | choicesBranch+| | | | | | | | | | | | |   minReads=5+| | | | | | | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | | | | | | |   alwaysRaise=[]+| | | | | | | | | | | | |   freeRegs=[]+| | | | | | | | | | | | | | <branch (\x_0 -> x_0)>+| | | | | | | | | | | | | | | call name+| | | | | | | | | | | | | | |   minReads=5+| | | | | | | | | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | | | | | | | | |   alwaysRaise=[]+| | | | | | | | | | | | | | |   freeRegs=[]+| | | | | | | | | | | | | | | refJoin join+| | | | | | | | | | | | | | |   minReads=0+| | | | | | | | | | | | | | |   mayRaise=[]+| | | | | | | | | | | | | | |   alwaysRaise=[]+| | | | | | | | | | | | | | |   freeRegs=[]+| | | | | | | | | | | | | | <default>+| | | | | | | | | | | | | | | fail []+| | | | | | | | | | | | | | |   minReads=0+| | | | | | | | | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | | | | | | | | |   alwaysRaise=[ExceptionFailure]+| | | | | | | | | | | | | | |   freeRegs=[]+| | | | | | | | | | <onException ExceptionFailure>+| | | | | | | | | | | comment "raiseAgainIfConsumed"+| | | | | | | | | | |   minReads=0+| | | | | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | | | | |   alwaysRaise=[]+| | | | | | | | | | |   freeRegs=[]+| | | | | | | | | | | saveInput+| | | | | | | | | | |   minReads=0+| | | | | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | | | | |   alwaysRaise=[]+| | | | | | | | | | |   freeRegs=[]+| | | | | | | | | | | lift2Value (\(Data.Text.Internal.Text _ i_0 _) (Data.Text.Internal.Text _+| | | | | | | | | | |                                                                j_1+| | | | | | | | | | |                                                                _) -> i_0 GHC.Classes.== j_1)+| | | | | | | | | | |   minReads=0+| | | | | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | | | | |   alwaysRaise=[]+| | | | | | | | | | |   freeRegs=[]+| | | | | | | | | | | choicesBranch+| | | | | | | | | | |   minReads=0+| | | | | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | | | | |   alwaysRaise=[]+| | | | | | | | | | |   freeRegs=[]+| | | | | | | | | | | | <branch (\x_0 -> x_0)>+| | | | | | | | | | | | | call name+| | | | | | | | | | | | |   minReads=0+| | | | | | | | | | | | |   mayRaise=[]+| | | | | | | | | | | | |   alwaysRaise=[]+| | | | | | | | | | | | |   freeRegs=[]+| | | | | | | | | | | | | refJoin join+| | | | | | | | | | | | |   minReads=0+| | | | | | | | | | | | |   mayRaise=[]+| | | | | | | | | | | | |   alwaysRaise=[]+| | | | | | | | | | | | |   freeRegs=[]+| | | | | | | | | | | | <default>+| | | | | | | | | | | | | fail []+| | | | | | | | | | | | |   minReads=0+| | | | | | | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | | | | | | |   alwaysRaise=[ExceptionFailure]+| | | | | | | | | | | | |   freeRegs=[]+| | | | | | | | <default>+| | | | | | | | | fail []+| | | | | | | | |   minReads=0+| | | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | | |   alwaysRaise=[ExceptionFailure]+| | | | | | | | |   freeRegs=[]+| | | | <default>+| | | | | fail []+| | | | |   minReads=0+| | | | |   mayRaise=[ExceptionFailure]+| | | | |   alwaysRaise=[ExceptionFailure]+| | | | |   freeRegs=[]+let name+  minReads=2+  mayRaise=[ExceptionFailure]+  alwaysRaise=[]+  freeRegs=[]+| pushValue (\x_0 -> \x_1 -> '(')+|   minReads=2+|   mayRaise=[ExceptionFailure]+|   alwaysRaise=[]+|   freeRegs=[]+| comment "satisfy ((GHC.Classes.==) '(')"+|   minReads=2+|   mayRaise=[ExceptionFailure]+|   alwaysRaise=[]+|   freeRegs=[]+| read ((GHC.Classes.==) '(')+|   minReads=2+|   mayRaise=[ExceptionFailure]+|   alwaysRaise=[]+|   freeRegs=[]+| lift2Value (\x_0 -> \x_1 -> x_0 x_1)+|   minReads=1+|   mayRaise=[ExceptionFailure]+|   alwaysRaise=[]+|   freeRegs=[]+| call name+|   minReads=1+|   mayRaise=[ExceptionFailure]+|   alwaysRaise=[]+|   freeRegs=[]+| lift2Value (\x_0 -> \x_1 -> x_0 x_1)+|   minReads=0+|   mayRaise=[]+|   alwaysRaise=[]+|   freeRegs=[]+| ret+|   minReads=0+|   mayRaise=[]+|   alwaysRaise=[]+|   freeRegs=[]+let name+  minReads=2+  mayRaise=[ExceptionFailure]+  alwaysRaise=[]+  freeRegs=[]+| pushValue (\x_0 -> \x_1 -> ')')+|   minReads=2+|   mayRaise=[ExceptionFailure]+|   alwaysRaise=[]+|   freeRegs=[]+| comment "satisfy ((GHC.Classes.==) ')')"+|   minReads=2+|   mayRaise=[ExceptionFailure]+|   alwaysRaise=[]+|   freeRegs=[]+| read ((GHC.Classes.==) ')')+|   minReads=2+|   mayRaise=[ExceptionFailure]+|   alwaysRaise=[]+|   freeRegs=[]+| lift2Value (\x_0 -> \x_1 -> x_0 x_1)+|   minReads=1+|   mayRaise=[ExceptionFailure]+|   alwaysRaise=[]+|   freeRegs=[]+| call name+|   minReads=1+|   mayRaise=[ExceptionFailure]+|   alwaysRaise=[]+|   freeRegs=[]+| lift2Value (\x_0 -> \x_1 -> x_0 x_1)+|   minReads=0+|   mayRaise=[]+|   alwaysRaise=[]+|   freeRegs=[]+| ret+|   minReads=0+|   mayRaise=[]+|   alwaysRaise=[]+|   freeRegs=[]+let name+  minReads=2+  mayRaise=[ExceptionFailure]+  alwaysRaise=[]+  freeRegs=[]+| pushValue (\x_0 -> \x_1 -> ',')+|   minReads=2+|   mayRaise=[ExceptionFailure]+|   alwaysRaise=[]+|   freeRegs=[]+| comment "satisfy ((GHC.Classes.==) ',')"+|   minReads=2+|   mayRaise=[ExceptionFailure]+|   alwaysRaise=[]+|   freeRegs=[]+| read ((GHC.Classes.==) ',')+|   minReads=2+|   mayRaise=[ExceptionFailure]+|   alwaysRaise=[]+|   freeRegs=[]+| lift2Value (\x_0 -> \x_1 -> x_0 x_1)+|   minReads=1+|   mayRaise=[ExceptionFailure]+|   alwaysRaise=[]+|   freeRegs=[]+| call name+|   minReads=1+|   mayRaise=[ExceptionFailure]+|   alwaysRaise=[]+|   freeRegs=[]+| lift2Value (\x_0 -> \x_1 -> x_0 x_1)+|   minReads=0+|   mayRaise=[]+|   alwaysRaise=[]+|   freeRegs=[]+| ret+|   minReads=0+|   mayRaise=[]+|   alwaysRaise=[]+|   freeRegs=[]+let name+  minReads=2+  mayRaise=[ExceptionFailure]+  alwaysRaise=[]+  freeRegs=[]+| pushValue (\x_0 -> \x_1 -> ';')+|   minReads=2+|   mayRaise=[ExceptionFailure]+|   alwaysRaise=[]+|   freeRegs=[]+| comment "satisfy ((GHC.Classes.==) ';')"+|   minReads=2+|   mayRaise=[ExceptionFailure]+|   alwaysRaise=[]+|   freeRegs=[]+| read ((GHC.Classes.==) ';')+|   minReads=2+|   mayRaise=[ExceptionFailure]+|   alwaysRaise=[]+|   freeRegs=[]+| lift2Value (\x_0 -> \x_1 -> x_0 x_1)+|   minReads=1+|   mayRaise=[ExceptionFailure]+|   alwaysRaise=[]+|   freeRegs=[]+| call name+|   minReads=1+|   mayRaise=[ExceptionFailure]+|   alwaysRaise=[]+|   freeRegs=[]+| lift2Value (\x_0 -> \x_1 -> x_0 x_1)+|   minReads=0+|   mayRaise=[]+|   alwaysRaise=[]+|   freeRegs=[]+| ret+|   minReads=0+|   mayRaise=[]+|   alwaysRaise=[]+|   freeRegs=[]+let name+  minReads=2+  mayRaise=[ExceptionFailure]+  alwaysRaise=[]+  freeRegs=[]+| pushValue (\x_0 -> \x_1 -> \x_2 -> x_2)+|   minReads=2+|   mayRaise=[ExceptionFailure]+|   alwaysRaise=[]+|   freeRegs=[]+| call name+|   minReads=2+|   mayRaise=[ExceptionFailure]+|   alwaysRaise=[]+|   freeRegs=[]+| lift2Value (\x_0 -> \x_1 -> x_0 x_1)+|   minReads=0+|   mayRaise=[ExceptionFailure]+|   alwaysRaise=[]+|   freeRegs=[]+| pushValue (\x_0 -> x_0)+|   minReads=0+|   mayRaise=[ExceptionFailure]+|   alwaysRaise=[]+|   freeRegs=[]+| newRegister reg+|   minReads=0+|   mayRaise=[ExceptionFailure]+|   alwaysRaise=[]+|   freeRegs=[]+| iter loop+|   minReads=0+|   mayRaise=[ExceptionFailure]+|   alwaysRaise=[]+|   freeRegs=[reg]+| | <ok>+| | | pushValue (\x_0 -> \x_1 -> \x_2 -> \x_3 -> x_3)+| | |   minReads=4+| | |   mayRaise=[ExceptionFailure]+| | |   alwaysRaise=[]+| | |   freeRegs=[reg]+| | | comment "satisfy ((GHC.Classes.==) '!')"+| | |   minReads=4+| | |   mayRaise=[ExceptionFailure]+| | |   alwaysRaise=[]+| | |   freeRegs=[reg]+| | | read ((GHC.Classes.==) '!')+| | |   minReads=4+| | |   mayRaise=[ExceptionFailure]+| | |   alwaysRaise=[]+| | |   freeRegs=[reg]+| | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| | |   minReads=3+| | |   mayRaise=[ExceptionFailure]+| | |   alwaysRaise=[]+| | |   freeRegs=[reg]+| | | call name+| | |   minReads=3+| | |   mayRaise=[ExceptionFailure]+| | |   alwaysRaise=[]+| | |   freeRegs=[reg]+| | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| | |   minReads=2+| | |   mayRaise=[ExceptionFailure]+| | |   alwaysRaise=[]+| | |   freeRegs=[reg]+| | | call name+| | |   minReads=2+| | |   mayRaise=[ExceptionFailure]+| | |   alwaysRaise=[]+| | |   freeRegs=[reg]+| | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| | |   minReads=0+| | |   mayRaise=[]+| | |   alwaysRaise=[]+| | |   freeRegs=[reg]+| | | readRegister reg+| | |   minReads=0+| | |   mayRaise=[]+| | |   alwaysRaise=[]+| | |   freeRegs=[reg]+| | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| | |   minReads=0+| | |   mayRaise=[]+| | |   alwaysRaise=[]+| | |   freeRegs=[reg]+| | | writeRegister reg+| | |   minReads=0+| | |   mayRaise=[]+| | |   alwaysRaise=[]+| | |   freeRegs=[reg]+| | | jump loop+| | |   minReads=0+| | |   mayRaise=[]+| | |   alwaysRaise=[]+| | |   freeRegs=[]+| | <ko>+| | | comment "raiseAgainIfConsumed"+| | |   minReads=0+| | |   mayRaise=[ExceptionFailure]+| | |   alwaysRaise=[]+| | |   freeRegs=[reg]+| | | saveInput+| | |   minReads=0+| | |   mayRaise=[ExceptionFailure]+| | |   alwaysRaise=[]+| | |   freeRegs=[reg]+| | | lift2Value (\(Data.Text.Internal.Text _ i_0 _) (Data.Text.Internal.Text _+| | |                                                                j_1+| | |                                                                _) -> i_0 GHC.Classes.== j_1)+| | |   minReads=0+| | |   mayRaise=[ExceptionFailure]+| | |   alwaysRaise=[]+| | |   freeRegs=[reg]+| | | choicesBranch+| | |   minReads=0+| | |   mayRaise=[ExceptionFailure]+| | |   alwaysRaise=[]+| | |   freeRegs=[reg]+| | | | <branch (\x_0 -> x_0)>+| | | | | readRegister reg+| | | | |   minReads=0+| | | | |   mayRaise=[]+| | | | |   alwaysRaise=[]+| | | | |   freeRegs=[reg]+| | | | | call name+| | | | |   minReads=0+| | | | |   mayRaise=[]+| | | | |   alwaysRaise=[]+| | | | |   freeRegs=[]+| | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| | | | |   minReads=0+| | | | |   mayRaise=[]+| | | | |   alwaysRaise=[]+| | | | |   freeRegs=[]+| | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| | | | |   minReads=0+| | | | |   mayRaise=[]+| | | | |   alwaysRaise=[]+| | | | |   freeRegs=[]+| | | | | call name+| | | | |   minReads=0+| | | | |   mayRaise=[]+| | | | |   alwaysRaise=[]+| | | | |   freeRegs=[]+| | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| | | | |   minReads=0+| | | | |   mayRaise=[]+| | | | |   alwaysRaise=[]+| | | | |   freeRegs=[]+| | | | | ret+| | | | |   minReads=0+| | | | |   mayRaise=[]+| | | | |   alwaysRaise=[]+| | | | |   freeRegs=[]+| | | | <default>+| | | | | fail []+| | | | |   minReads=0+| | | | |   mayRaise=[ExceptionFailure]+| | | | |   alwaysRaise=[ExceptionFailure]+| | | | |   freeRegs=[]+let name+  minReads=2+  mayRaise=[ExceptionFailure]+  alwaysRaise=[]+  freeRegs=[]+| pushValue (\x_0 -> \x_1 -> x_1)+|   minReads=2+|   mayRaise=[ExceptionFailure]+|   alwaysRaise=[]+|   freeRegs=[]+| call name+|   minReads=2+|   mayRaise=[ExceptionFailure]+|   alwaysRaise=[]+|   freeRegs=[]+| lift2Value (\x_0 -> \x_1 -> x_0 x_1)+|   minReads=0+|   mayRaise=[ExceptionFailure]+|   alwaysRaise=[]+|   freeRegs=[]+| join join+|   minReads=0+|   mayRaise=[]+|   alwaysRaise=[]+|   freeRegs=[]+| | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| |   minReads=0+| |   mayRaise=[]+| |   alwaysRaise=[]+| |   freeRegs=[]+| | ret+| |   minReads=0+| |   mayRaise=[]+| |   alwaysRaise=[]+| |   freeRegs=[]+| catch ExceptionFailure+|   minReads=0+|   mayRaise=[ExceptionFailure]+|   alwaysRaise=[]+|   freeRegs=[]+| | <catchScope>+| | | pushValue (\x_0 -> GHC.Tuple.())+| | |   minReads=5+| | |   mayRaise=[ExceptionFailure]+| | |   alwaysRaise=[]+| | |   freeRegs=[]+| | | call name+| | |   minReads=5+| | |   mayRaise=[ExceptionFailure]+| | |   alwaysRaise=[]+| | |   freeRegs=[]+| | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| | |   minReads=0+| | |   mayRaise=[]+| | |   alwaysRaise=[]+| | |   freeRegs=[]+| | | commit ExceptionFailure+| | |   minReads=0+| | |   mayRaise=[]+| | |   alwaysRaise=[]+| | |   freeRegs=[]+| | | refJoin join+| | |   minReads=0+| | |   mayRaise=[]+| | |   alwaysRaise=[]+| | |   freeRegs=[]+| | <onException ExceptionFailure>+| | | comment "raiseAgainIfConsumed"+| | |   minReads=0+| | |   mayRaise=[ExceptionFailure]+| | |   alwaysRaise=[]+| | |   freeRegs=[]+| | | saveInput+| | |   minReads=0+| | |   mayRaise=[ExceptionFailure]+| | |   alwaysRaise=[]+| | |   freeRegs=[]+| | | lift2Value (\(Data.Text.Internal.Text _ i_0 _) (Data.Text.Internal.Text _+| | |                                                                j_1+| | |                                                                _) -> i_0 GHC.Classes.== j_1)+| | |   minReads=0+| | |   mayRaise=[ExceptionFailure]+| | |   alwaysRaise=[]+| | |   freeRegs=[]+| | | choicesBranch+| | |   minReads=0+| | |   mayRaise=[ExceptionFailure]+| | |   alwaysRaise=[]+| | |   freeRegs=[]+| | | | <branch (\x_0 -> x_0)>+| | | | | call name+| | | | |   minReads=0+| | | | |   mayRaise=[]+| | | | |   alwaysRaise=[]+| | | | |   freeRegs=[]+| | | | | refJoin join+| | | | |   minReads=0+| | | | |   mayRaise=[]+| | | | |   alwaysRaise=[]+| | | | |   freeRegs=[]+| | | | <default>+| | | | | fail []+| | | | |   minReads=0+| | | | |   mayRaise=[ExceptionFailure]+| | | | |   alwaysRaise=[ExceptionFailure]+| | | | |   freeRegs=[]+let name+  minReads=2+  mayRaise=[ExceptionFailure]+  alwaysRaise=[]+  freeRegs=[]+| pushValue (\x_0 -> \x_1 -> x_1)+|   minReads=2+|   mayRaise=[ExceptionFailure]+|   alwaysRaise=[]+|   freeRegs=[]+| catch ExceptionFailure+|   minReads=2+|   mayRaise=[ExceptionFailure]+|   alwaysRaise=[]+|   freeRegs=[]+| | <catchScope>+| | | pushValue (\x_0 -> \x_1 -> \x_2 -> x_2)+| | |   minReads=2+| | |   mayRaise=[ExceptionFailure]+| | |   alwaysRaise=[]+| | |   freeRegs=[]+| | | comment "satisfy Parsers.Nandlang.nandIdentStart"+| | |   minReads=2+| | |   mayRaise=[ExceptionFailure]+| | |   alwaysRaise=[]+| | |   freeRegs=[]+| | | read Parsers.Nandlang.nandIdentStart+| | |   minReads=2+| | |   mayRaise=[ExceptionFailure]+| | |   alwaysRaise=[]+| | |   freeRegs=[]+| | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| | |   minReads=1+| | |   mayRaise=[ExceptionFailure]+| | |   alwaysRaise=[]+| | |   freeRegs=[]+| | | pushValue (\x_0 -> x_0)+| | |   minReads=1+| | |   mayRaise=[ExceptionFailure]+| | |   alwaysRaise=[]+| | |   freeRegs=[]+| | | newRegister reg+| | |   minReads=1+| | |   mayRaise=[ExceptionFailure]+| | |   alwaysRaise=[]+| | |   freeRegs=[]+| | | iter loop+| | |   minReads=1+| | |   mayRaise=[ExceptionFailure]+| | |   alwaysRaise=[]+| | |   freeRegs=[reg]+| | | | <ok>+| | | | | pushValue (\x_0 -> \x_1 -> x_1)+| | | | |   minReads=1+| | | | |   mayRaise=[ExceptionFailure]+| | | | |   alwaysRaise=[]+| | | | |   freeRegs=[reg]+| | | | | comment "satisfy Parsers.Nandlang.nandIdentLetter"+| | | | |   minReads=1+| | | | |   mayRaise=[ExceptionFailure]+| | | | |   alwaysRaise=[]+| | | | |   freeRegs=[reg]+| | | | | read Parsers.Nandlang.nandIdentLetter+| | | | |   minReads=1+| | | | |   mayRaise=[ExceptionFailure]+| | | | |   alwaysRaise=[]+| | | | |   freeRegs=[reg]+| | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| | | | |   minReads=0+| | | | |   mayRaise=[]+| | | | |   alwaysRaise=[]+| | | | |   freeRegs=[reg]+| | | | | readRegister reg+| | | | |   minReads=0+| | | | |   mayRaise=[]+| | | | |   alwaysRaise=[]+| | | | |   freeRegs=[reg]+| | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| | | | |   minReads=0+| | | | |   mayRaise=[]+| | | | |   alwaysRaise=[]+| | | | |   freeRegs=[reg]+| | | | | writeRegister reg+| | | | |   minReads=0+| | | | |   mayRaise=[]+| | | | |   alwaysRaise=[]+| | | | |   freeRegs=[reg]+| | | | | jump loop+| | | | |   minReads=0+| | | | |   mayRaise=[]+| | | | |   alwaysRaise=[]+| | | | |   freeRegs=[]+| | | | <ko>+| | | | | comment "raiseAgainIfConsumed"+| | | | |   minReads=1+| | | | |   mayRaise=[ExceptionFailure]+| | | | |   alwaysRaise=[]+| | | | |   freeRegs=[reg]+| | | | | saveInput+| | | | |   minReads=1+| | | | |   mayRaise=[ExceptionFailure]+| | | | |   alwaysRaise=[]+| | | | |   freeRegs=[reg]+| | | | | lift2Value (\(Data.Text.Internal.Text _ i_0 _) (Data.Text.Internal.Text _+| | | | |                                                                j_1+| | | | |                                                                _) -> i_0 GHC.Classes.== j_1)+| | | | |   minReads=1+| | | | |   mayRaise=[ExceptionFailure]+| | | | |   alwaysRaise=[]+| | | | |   freeRegs=[reg]+| | | | | choicesBranch+| | | | |   minReads=1+| | | | |   mayRaise=[ExceptionFailure]+| | | | |   alwaysRaise=[]+| | | | |   freeRegs=[reg]+| | | | | | <branch (\x_0 -> x_0)>+| | | | | | | readRegister reg+| | | | | | |   minReads=1+| | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | |   alwaysRaise=[]+| | | | | | |   freeRegs=[reg]+| | | | | | | call name+| | | | | | |   minReads=1+| | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | |   alwaysRaise=[]+| | | | | | |   freeRegs=[]+| | | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| | | | | | |   minReads=1+| | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | |   alwaysRaise=[]+| | | | | | |   freeRegs=[]+| | | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| | | | | | |   minReads=1+| | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | |   alwaysRaise=[]+| | | | | | |   freeRegs=[]+| | | | | | | call name+| | | | | | |   minReads=1+| | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | |   alwaysRaise=[]+| | | | | | |   freeRegs=[]+| | | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| | | | | | |   minReads=1+| | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | |   alwaysRaise=[]+| | | | | | |   freeRegs=[]+| | | | | | | commit ExceptionFailure+| | | | | | |   minReads=1+| | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | |   alwaysRaise=[]+| | | | | | |   freeRegs=[]+| | | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| | | | | | |   minReads=1+| | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | |   alwaysRaise=[]+| | | | | | |   freeRegs=[]+| | | | | | | call name+| | | | | | |   minReads=1+| | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | |   alwaysRaise=[]+| | | | | | |   freeRegs=[]+| | | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| | | | | | |   minReads=0+| | | | | | |   mayRaise=[]+| | | | | | |   alwaysRaise=[]+| | | | | | |   freeRegs=[]+| | | | | | | ret+| | | | | | |   minReads=0+| | | | | | |   mayRaise=[]+| | | | | | |   alwaysRaise=[]+| | | | | | |   freeRegs=[]+| | | | | | <default>+| | | | | | | fail []+| | | | | | |   minReads=0+| | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | |   alwaysRaise=[ExceptionFailure]+| | | | | | |   freeRegs=[]+| | <onException ExceptionFailure>+| | | loadInput+| | |   minReads=0+| | |   mayRaise=[ExceptionFailure]+| | |   alwaysRaise=[ExceptionFailure]+| | |   freeRegs=[]+| | | fail []+| | |   minReads=0+| | |   mayRaise=[ExceptionFailure]+| | |   alwaysRaise=[ExceptionFailure]+| | |   freeRegs=[]+let name+  minReads=4+  mayRaise=[ExceptionFailure]+  alwaysRaise=[]+  freeRegs=[]+| pushValue (\x_0 -> \x_1 -> \x_2 -> \x_3 -> \x_4 -> \x_5 -> x_3)+|   minReads=4+|   mayRaise=[ExceptionFailure]+|   alwaysRaise=[]+|   freeRegs=[]+| comment "satisfy ((GHC.Classes.==) '{')"+|   minReads=4+|   mayRaise=[ExceptionFailure]+|   alwaysRaise=[]+|   freeRegs=[]+| read ((GHC.Classes.==) '{')+|   minReads=4+|   mayRaise=[ExceptionFailure]+|   alwaysRaise=[]+|   freeRegs=[]+| lift2Value (\x_0 -> \x_1 -> x_0 x_1)+|   minReads=3+|   mayRaise=[ExceptionFailure]+|   alwaysRaise=[]+|   freeRegs=[]+| call name+|   minReads=3+|   mayRaise=[ExceptionFailure]+|   alwaysRaise=[]+|   freeRegs=[]+| lift2Value (\x_0 -> \x_1 -> x_0 x_1)+|   minReads=2+|   mayRaise=[ExceptionFailure]+|   alwaysRaise=[]+|   freeRegs=[]+| pushValue (\x_0 -> x_0)+|   minReads=2+|   mayRaise=[ExceptionFailure]+|   alwaysRaise=[]+|   freeRegs=[]+| newRegister reg+|   minReads=2+|   mayRaise=[ExceptionFailure]+|   alwaysRaise=[]+|   freeRegs=[]+| iter loop+|   minReads=2+|   mayRaise=[ExceptionFailure]+|   alwaysRaise=[]+|   freeRegs=[reg]+| | <ok>+| | | pushValue (\x_0 -> \x_1 -> x_1)+| | |   minReads=2+| | |   mayRaise=[ExceptionFailure]+| | |   alwaysRaise=[]+| | |   freeRegs=[reg]+| | | join join+| | |   minReads=0+| | |   mayRaise=[]+| | |   alwaysRaise=[]+| | |   freeRegs=[reg]+| | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| | | |   minReads=0+| | | |   mayRaise=[]+| | | |   alwaysRaise=[]+| | | |   freeRegs=[reg]+| | | | readRegister reg+| | | |   minReads=0+| | | |   mayRaise=[]+| | | |   alwaysRaise=[]+| | | |   freeRegs=[reg]+| | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| | | |   minReads=0+| | | |   mayRaise=[]+| | | |   alwaysRaise=[]+| | | |   freeRegs=[reg]+| | | | writeRegister reg+| | | |   minReads=0+| | | |   mayRaise=[]+| | | |   alwaysRaise=[]+| | | |   freeRegs=[reg]+| | | | jump loop+| | | |   minReads=0+| | | |   mayRaise=[]+| | | |   alwaysRaise=[]+| | | |   freeRegs=[]+| | | catch ExceptionFailure+| | |   minReads=2+| | |   mayRaise=[ExceptionFailure]+| | |   alwaysRaise=[]+| | |   freeRegs=[reg]+| | | | <catchScope>+| | | | | pushValue (\x_0 -> \x_1 -> x_1)+| | | | |   minReads=2+| | | | |   mayRaise=[ExceptionFailure]+| | | | |   alwaysRaise=[]+| | | | |   freeRegs=[reg]+| | | | | catch ExceptionFailure+| | | | |   minReads=2+| | | | |   mayRaise=[ExceptionFailure]+| | | | |   alwaysRaise=[]+| | | | |   freeRegs=[reg]+| | | | | | <catchScope>+| | | | | | | pushValue (\x_0 -> \x_1 -> (GHC.Types.:) 'i' ((GHC.Types.:) 'f' GHC.Types.[]))+| | | | | | |   minReads=2+| | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | |   alwaysRaise=[]+| | | | | | |   freeRegs=[reg]+| | | | | | | comment "satisfy ((GHC.Classes.==) 'i')"+| | | | | | |   minReads=2+| | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | |   alwaysRaise=[]+| | | | | | |   freeRegs=[reg]+| | | | | | | read ((GHC.Classes.==) 'i')+| | | | | | |   minReads=2+| | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | |   alwaysRaise=[]+| | | | | | |   freeRegs=[reg]+| | | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| | | | | | |   minReads=1+| | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | |   alwaysRaise=[]+| | | | | | |   freeRegs=[reg]+| | | | | | | comment "satisfy ((GHC.Classes.==) 'f')"+| | | | | | |   minReads=1+| | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | |   alwaysRaise=[]+| | | | | | |   freeRegs=[reg]+| | | | | | | read ((GHC.Classes.==) 'f')+| | | | | | |   minReads=1+| | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | |   alwaysRaise=[]+| | | | | | |   freeRegs=[reg]+| | | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| | | | | | |   minReads=0+| | | | | | |   mayRaise=[]+| | | | | | |   alwaysRaise=[]+| | | | | | |   freeRegs=[reg]+| | | | | | | commit ExceptionFailure+| | | | | | |   minReads=0+| | | | | | |   mayRaise=[]+| | | | | | |   alwaysRaise=[]+| | | | | | |   freeRegs=[reg]+| | | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| | | | | | |   minReads=0+| | | | | | |   mayRaise=[]+| | | | | | |   alwaysRaise=[]+| | | | | | |   freeRegs=[reg]+| | | | | | | call name+| | | | | | |   minReads=0+| | | | | | |   mayRaise=[]+| | | | | | |   alwaysRaise=[]+| | | | | | |   freeRegs=[reg]+| | | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| | | | | | |   minReads=0+| | | | | | |   mayRaise=[]+| | | | | | |   alwaysRaise=[]+| | | | | | |   freeRegs=[reg]+| | | | | | | commit ExceptionFailure+| | | | | | |   minReads=0+| | | | | | |   mayRaise=[]+| | | | | | |   alwaysRaise=[]+| | | | | | |   freeRegs=[reg]+| | | | | | | refJoin join+| | | | | | |   minReads=0+| | | | | | |   mayRaise=[]+| | | | | | |   alwaysRaise=[]+| | | | | | |   freeRegs=[reg]+| | | | | | <onException ExceptionFailure>+| | | | | | | loadInput+| | | | | | |   minReads=0+| | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | |   alwaysRaise=[ExceptionFailure]+| | | | | | |   freeRegs=[]+| | | | | | | fail []+| | | | | | |   minReads=0+| | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | |   alwaysRaise=[ExceptionFailure]+| | | | | | |   freeRegs=[]+| | | | <onException ExceptionFailure>+| | | | | comment "raiseAgainIfConsumed"+| | | | |   minReads=4+| | | | |   mayRaise=[ExceptionFailure]+| | | | |   alwaysRaise=[]+| | | | |   freeRegs=[reg]+| | | | | saveInput+| | | | |   minReads=4+| | | | |   mayRaise=[ExceptionFailure]+| | | | |   alwaysRaise=[]+| | | | |   freeRegs=[reg]+| | | | | lift2Value (\(Data.Text.Internal.Text _ i_0 _) (Data.Text.Internal.Text _+| | | | |                                                                j_1+| | | | |                                                                _) -> i_0 GHC.Classes.== j_1)+| | | | |   minReads=4+| | | | |   mayRaise=[ExceptionFailure]+| | | | |   alwaysRaise=[]+| | | | |   freeRegs=[reg]+| | | | | choicesBranch+| | | | |   minReads=4+| | | | |   mayRaise=[ExceptionFailure]+| | | | |   alwaysRaise=[]+| | | | |   freeRegs=[reg]+| | | | | | <branch (\x_0 -> x_0)>+| | | | | | | catch ExceptionFailure+| | | | | | |   minReads=4+| | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | |   alwaysRaise=[]+| | | | | | |   freeRegs=[reg]+| | | | | | | | <catchScope>+| | | | | | | | | pushValue (\x_0 -> \x_1 -> \x_2 -> \x_3 -> x_3)+| | | | | | | | |   minReads=7+| | | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | | |   alwaysRaise=[]+| | | | | | | | |   freeRegs=[]+| | | | | | | | | catch ExceptionFailure+| | | | | | | | |   minReads=7+| | | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | | |   alwaysRaise=[]+| | | | | | | | |   freeRegs=[]+| | | | | | | | | | <catchScope>+| | | | | | | | | | | pushValue (\x_0 -> \x_1 -> \x_2 -> \x_3 -> \x_4 -> (GHC.Types.:) 'w' ((GHC.Types.:) 'h' ((GHC.Types.:) 'i' ((GHC.Types.:) 'l' ((GHC.Types.:) 'e' GHC.Types.[])))))+| | | | | | | | | | |   minReads=7+| | | | | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | | | | |   alwaysRaise=[]+| | | | | | | | | | |   freeRegs=[]+| | | | | | | | | | | comment "satisfy ((GHC.Classes.==) 'w')"+| | | | | | | | | | |   minReads=7+| | | | | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | | | | |   alwaysRaise=[]+| | | | | | | | | | |   freeRegs=[]+| | | | | | | | | | | read ((GHC.Classes.==) 'w')+| | | | | | | | | | |   minReads=7+| | | | | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | | | | |   alwaysRaise=[]+| | | | | | | | | | |   freeRegs=[]+| | | | | | | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| | | | | | | | | | |   minReads=6+| | | | | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | | | | |   alwaysRaise=[]+| | | | | | | | | | |   freeRegs=[]+| | | | | | | | | | | comment "satisfy ((GHC.Classes.==) 'h')"+| | | | | | | | | | |   minReads=6+| | | | | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | | | | |   alwaysRaise=[]+| | | | | | | | | | |   freeRegs=[]+| | | | | | | | | | | read ((GHC.Classes.==) 'h')+| | | | | | | | | | |   minReads=6+| | | | | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | | | | |   alwaysRaise=[]+| | | | | | | | | | |   freeRegs=[]+| | | | | | | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| | | | | | | | | | |   minReads=5+| | | | | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | | | | |   alwaysRaise=[]+| | | | | | | | | | |   freeRegs=[]+| | | | | | | | | | | comment "satisfy ((GHC.Classes.==) 'i')"+| | | | | | | | | | |   minReads=5+| | | | | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | | | | |   alwaysRaise=[]+| | | | | | | | | | |   freeRegs=[]+| | | | | | | | | | | read ((GHC.Classes.==) 'i')+| | | | | | | | | | |   minReads=5+| | | | | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | | | | |   alwaysRaise=[]+| | | | | | | | | | |   freeRegs=[]+| | | | | | | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| | | | | | | | | | |   minReads=4+| | | | | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | | | | |   alwaysRaise=[]+| | | | | | | | | | |   freeRegs=[]+| | | | | | | | | | | comment "satisfy ((GHC.Classes.==) 'l')"+| | | | | | | | | | |   minReads=4+| | | | | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | | | | |   alwaysRaise=[]+| | | | | | | | | | |   freeRegs=[]+| | | | | | | | | | | read ((GHC.Classes.==) 'l')+| | | | | | | | | | |   minReads=4+| | | | | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | | | | |   alwaysRaise=[]+| | | | | | | | | | |   freeRegs=[]+| | | | | | | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| | | | | | | | | | |   minReads=3+| | | | | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | | | | |   alwaysRaise=[]+| | | | | | | | | | |   freeRegs=[]+| | | | | | | | | | | comment "satisfy ((GHC.Classes.==) 'e')"+| | | | | | | | | | |   minReads=3+| | | | | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | | | | |   alwaysRaise=[]+| | | | | | | | | | |   freeRegs=[]+| | | | | | | | | | | read ((GHC.Classes.==) 'e')+| | | | | | | | | | |   minReads=3+| | | | | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | | | | |   alwaysRaise=[]+| | | | | | | | | | |   freeRegs=[]+| | | | | | | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| | | | | | | | | | |   minReads=2+| | | | | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | | | | |   alwaysRaise=[]+| | | | | | | | | | |   freeRegs=[]+| | | | | | | | | | | commit ExceptionFailure+| | | | | | | | | | |   minReads=2+| | | | | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | | | | |   alwaysRaise=[]+| | | | | | | | | | |   freeRegs=[]+| | | | | | | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| | | | | | | | | | |   minReads=2+| | | | | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | | | | |   alwaysRaise=[]+| | | | | | | | | | |   freeRegs=[]+| | | | | | | | | | | call name+| | | | | | | | | | |   minReads=2+| | | | | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | | | | |   alwaysRaise=[]+| | | | | | | | | | |   freeRegs=[]+| | | | | | | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| | | | | | | | | | |   minReads=2+| | | | | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | | | | |   alwaysRaise=[]+| | | | | | | | | | |   freeRegs=[]+| | | | | | | | | | | call name+| | | | | | | | | | |   minReads=2+| | | | | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | | | | |   alwaysRaise=[]+| | | | | | | | | | |   freeRegs=[]+| | | | | | | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| | | | | | | | | | |   minReads=0+| | | | | | | | | | |   mayRaise=[]+| | | | | | | | | | |   alwaysRaise=[]+| | | | | | | | | | |   freeRegs=[]+| | | | | | | | | | | call name+| | | | | | | | | | |   minReads=0+| | | | | | | | | | |   mayRaise=[]+| | | | | | | | | | |   alwaysRaise=[]+| | | | | | | | | | |   freeRegs=[]+| | | | | | | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| | | | | | | | | | |   minReads=0+| | | | | | | | | | |   mayRaise=[]+| | | | | | | | | | |   alwaysRaise=[]+| | | | | | | | | | |   freeRegs=[reg]+| | | | | | | | | | | commit ExceptionFailure+| | | | | | | | | | |   minReads=0+| | | | | | | | | | |   mayRaise=[]+| | | | | | | | | | |   alwaysRaise=[]+| | | | | | | | | | |   freeRegs=[reg]+| | | | | | | | | | | refJoin join+| | | | | | | | | | |   minReads=0+| | | | | | | | | | |   mayRaise=[]+| | | | | | | | | | |   alwaysRaise=[]+| | | | | | | | | | |   freeRegs=[reg]+| | | | | | | | | | <onException ExceptionFailure>+| | | | | | | | | | | loadInput+| | | | | | | | | | |   minReads=0+| | | | | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | | | | |   alwaysRaise=[ExceptionFailure]+| | | | | | | | | | |   freeRegs=[]+| | | | | | | | | | | fail []+| | | | | | | | | | |   minReads=0+| | | | | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | | | | |   alwaysRaise=[ExceptionFailure]+| | | | | | | | | | |   freeRegs=[]+| | | | | | | | <onException ExceptionFailure>+| | | | | | | | | comment "raiseAgainIfConsumed"+| | | | | | | | |   minReads=4+| | | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | | |   alwaysRaise=[]+| | | | | | | | |   freeRegs=[reg]+| | | | | | | | | saveInput+| | | | | | | | |   minReads=4+| | | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | | |   alwaysRaise=[]+| | | | | | | | |   freeRegs=[reg]+| | | | | | | | | lift2Value (\(Data.Text.Internal.Text _ i_0 _) (Data.Text.Internal.Text _+| | | | | | | | |                                                                j_1+| | | | | | | | |                                                                _) -> i_0 GHC.Classes.== j_1)+| | | | | | | | |   minReads=4+| | | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | | |   alwaysRaise=[]+| | | | | | | | |   freeRegs=[reg]+| | | | | | | | | choicesBranch+| | | | | | | | |   minReads=4+| | | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | | |   alwaysRaise=[]+| | | | | | | | |   freeRegs=[reg]+| | | | | | | | | | <branch (\x_0 -> x_0)>+| | | | | | | | | | | catch ExceptionFailure+| | | | | | | | | | |   minReads=4+| | | | | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | | | | |   alwaysRaise=[]+| | | | | | | | | | |   freeRegs=[reg]+| | | | | | | | | | | | <catchScope>+| | | | | | | | | | | | | catch ExceptionFailure+| | | | | | | | | | | | |   minReads=8+| | | | | | | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | | | | | | |   alwaysRaise=[]+| | | | | | | | | | | | |   freeRegs=[reg]+| | | | | | | | | | | | | | <catchScope>+| | | | | | | | | | | | | | | pushValue (\x_0 -> \x_1 -> \x_2 -> \x_3 -> \x_4 -> \x_5 -> \x_6 -> \x_7 -> \x_8 -> \x_9 -> x_8)+| | | | | | | | | | | | | | |   minReads=8+| | | | | | | | | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | | | | | | | | |   alwaysRaise=[]+| | | | | | | | | | | | | | |   freeRegs=[reg]+| | | | | | | | | | | | | | | join join+| | | | | | | | | | | | | | |   minReads=8+| | | | | | | | | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | | | | | | | | |   alwaysRaise=[]+| | | | | | | | | | | | | | |   freeRegs=[reg]+| | | | | | | | | | | | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| | | | | | | | | | | | | | | |   minReads=8+| | | | | | | | | | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | | | | | | | | | |   alwaysRaise=[]+| | | | | | | | | | | | | | | |   freeRegs=[reg]+| | | | | | | | | | | | | | | | call name+| | | | | | | | | | | | | | | |   minReads=8+| | | | | | | | | | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | | | | | | | | | |   alwaysRaise=[]+| | | | | | | | | | | | | | | |   freeRegs=[reg]+| | | | | | | | | | | | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| | | | | | | | | | | | | | | |   minReads=6+| | | | | | | | | | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | | | | | | | | | |   alwaysRaise=[]+| | | | | | | | | | | | | | | |   freeRegs=[reg]+| | | | | | | | | | | | | | | | pushValue (\x_0 -> x_0)+| | | | | | | | | | | | | | | |   minReads=6+| | | | | | | | | | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | | | | | | | | | |   alwaysRaise=[]+| | | | | | | | | | | | | | | |   freeRegs=[reg]+| | | | | | | | | | | | | | | | newRegister reg+| | | | | | | | | | | | | | | |   minReads=6+| | | | | | | | | | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | | | | | | | | | |   alwaysRaise=[]+| | | | | | | | | | | | | | | |   freeRegs=[reg]+| | | | | | | | | | | | | | | | iter loop+| | | | | | | | | | | | | | | |   minReads=6+| | | | | | | | | | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | | | | | | | | | |   alwaysRaise=[]+| | | | | | | | | | | | | | | |   freeRegs=[reg,reg]+| | | | | | | | | | | | | | | | | <ok>+| | | | | | | | | | | | | | | | | | pushValue (\x_0 -> \x_1 -> \x_2 -> x_0 x_2)+| | | | | | | | | | | | | | | | | |   minReads=4+| | | | | | | | | | | | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | | | | | | | | | | | |   alwaysRaise=[]+| | | | | | | | | | | | | | | | | |   freeRegs=[reg]+| | | | | | | | | | | | | | | | | | call name+| | | | | | | | | | | | | | | | | |   minReads=4+| | | | | | | | | | | | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | | | | | | | | | | | |   alwaysRaise=[]+| | | | | | | | | | | | | | | | | |   freeRegs=[reg]+| | | | | | | | | | | | | | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| | | | | | | | | | | | | | | | | |   minReads=4+| | | | | | | | | | | | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | | | | | | | | | | | |   alwaysRaise=[]+| | | | | | | | | | | | | | | | | |   freeRegs=[reg]+| | | | | | | | | | | | | | | | | | call name+| | | | | | | | | | | | | | | | | |   minReads=4+| | | | | | | | | | | | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | | | | | | | | | | | |   alwaysRaise=[]+| | | | | | | | | | | | | | | | | |   freeRegs=[reg]+| | | | | | | | | | | | | | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| | | | | | | | | | | | | | | | | |   minReads=2+| | | | | | | | | | | | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | | | | | | | | | | | |   alwaysRaise=[]+| | | | | | | | | | | | | | | | | |   freeRegs=[reg]+| | | | | | | | | | | | | | | | | | call name+| | | | | | | | | | | | | | | | | |   minReads=2+| | | | | | | | | | | | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | | | | | | | | | | | |   alwaysRaise=[]+| | | | | | | | | | | | | | | | | |   freeRegs=[reg]+| | | | | | | | | | | | | | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| | | | | | | | | | | | | | | | | |   minReads=0+| | | | | | | | | | | | | | | | | |   mayRaise=[]+| | | | | | | | | | | | | | | | | |   alwaysRaise=[]+| | | | | | | | | | | | | | | | | |   freeRegs=[reg]+| | | | | | | | | | | | | | | | | | readRegister reg+| | | | | | | | | | | | | | | | | |   minReads=0+| | | | | | | | | | | | | | | | | |   mayRaise=[]+| | | | | | | | | | | | | | | | | |   alwaysRaise=[]+| | | | | | | | | | | | | | | | | |   freeRegs=[reg]+| | | | | | | | | | | | | | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| | | | | | | | | | | | | | | | | |   minReads=0+| | | | | | | | | | | | | | | | | |   mayRaise=[]+| | | | | | | | | | | | | | | | | |   alwaysRaise=[]+| | | | | | | | | | | | | | | | | |   freeRegs=[reg]+| | | | | | | | | | | | | | | | | | writeRegister reg+| | | | | | | | | | | | | | | | | |   minReads=0+| | | | | | | | | | | | | | | | | |   mayRaise=[]+| | | | | | | | | | | | | | | | | |   alwaysRaise=[]+| | | | | | | | | | | | | | | | | |   freeRegs=[reg]+| | | | | | | | | | | | | | | | | | jump loop+| | | | | | | | | | | | | | | | | |   minReads=0+| | | | | | | | | | | | | | | | | |   mayRaise=[]+| | | | | | | | | | | | | | | | | |   alwaysRaise=[]+| | | | | | | | | | | | | | | | | |   freeRegs=[]+| | | | | | | | | | | | | | | | | <ko>+| | | | | | | | | | | | | | | | | | comment "raiseAgainIfConsumed"+| | | | | | | | | | | | | | | | | |   minReads=6+| | | | | | | | | | | | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | | | | | | | | | | | |   alwaysRaise=[]+| | | | | | | | | | | | | | | | | |   freeRegs=[reg,reg]+| | | | | | | | | | | | | | | | | | saveInput+| | | | | | | | | | | | | | | | | |   minReads=6+| | | | | | | | | | | | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | | | | | | | | | | | |   alwaysRaise=[]+| | | | | | | | | | | | | | | | | |   freeRegs=[reg,reg]+| | | | | | | | | | | | | | | | | | lift2Value (\(Data.Text.Internal.Text _ i_0 _) (Data.Text.Internal.Text _+| | | | | | | | | | | | | | | | | |                                                                j_1+| | | | | | | | | | | | | | | | | |                                                                _) -> i_0 GHC.Classes.== j_1)+| | | | | | | | | | | | | | | | | |   minReads=6+| | | | | | | | | | | | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | | | | | | | | | | | |   alwaysRaise=[]+| | | | | | | | | | | | | | | | | |   freeRegs=[reg,reg]+| | | | | | | | | | | | | | | | | | choicesBranch+| | | | | | | | | | | | | | | | | |   minReads=6+| | | | | | | | | | | | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | | | | | | | | | | | |   alwaysRaise=[]+| | | | | | | | | | | | | | | | | |   freeRegs=[reg,reg]+| | | | | | | | | | | | | | | | | | | <branch (\x_0 -> x_0)>+| | | | | | | | | | | | | | | | | | | | readRegister reg+| | | | | | | | | | | | | | | | | | | |   minReads=6+| | | | | | | | | | | | | | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | | | | | | | | | | | | | |   alwaysRaise=[]+| | | | | | | | | | | | | | | | | | | |   freeRegs=[reg,reg]+| | | | | | | | | | | | | | | | | | | | call name+| | | | | | | | | | | | | | | | | | | |   minReads=6+| | | | | | | | | | | | | | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | | | | | | | | | | | | | |   alwaysRaise=[]+| | | | | | | | | | | | | | | | | | | |   freeRegs=[reg]+| | | | | | | | | | | | | | | | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| | | | | | | | | | | | | | | | | | | |   minReads=6+| | | | | | | | | | | | | | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | | | | | | | | | | | | | |   alwaysRaise=[]+| | | | | | | | | | | | | | | | | | | |   freeRegs=[reg]+| | | | | | | | | | | | | | | | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| | | | | | | | | | | | | | | | | | | |   minReads=6+| | | | | | | | | | | | | | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | | | | | | | | | | | | | |   alwaysRaise=[]+| | | | | | | | | | | | | | | | | | | |   freeRegs=[reg]+| | | | | | | | | | | | | | | | | | | | call name+| | | | | | | | | | | | | | | | | | | |   minReads=6+| | | | | | | | | | | | | | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | | | | | | | | | | | | | |   alwaysRaise=[]+| | | | | | | | | | | | | | | | | | | |   freeRegs=[reg]+| | | | | | | | | | | | | | | | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| | | | | | | | | | | | | | | | | | | |   minReads=6+| | | | | | | | | | | | | | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | | | | | | | | | | | | | |   alwaysRaise=[]+| | | | | | | | | | | | | | | | | | | |   freeRegs=[reg]+| | | | | | | | | | | | | | | | | | | | comment "satisfy ((GHC.Classes.==) '=')"+| | | | | | | | | | | | | | | | | | | |   minReads=6+| | | | | | | | | | | | | | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | | | | | | | | | | | | | |   alwaysRaise=[]+| | | | | | | | | | | | | | | | | | | |   freeRegs=[reg]+| | | | | | | | | | | | | | | | | | | | read ((GHC.Classes.==) '=')+| | | | | | | | | | | | | | | | | | | |   minReads=6+| | | | | | | | | | | | | | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | | | | | | | | | | | | | |   alwaysRaise=[]+| | | | | | | | | | | | | | | | | | | |   freeRegs=[reg]+| | | | | | | | | | | | | | | | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| | | | | | | | | | | | | | | | | | | |   minReads=5+| | | | | | | | | | | | | | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | | | | | | | | | | | | | |   alwaysRaise=[]+| | | | | | | | | | | | | | | | | | | |   freeRegs=[reg]+| | | | | | | | | | | | | | | | | | | | call name+| | | | | | | | | | | | | | | | | | | |   minReads=5+| | | | | | | | | | | | | | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | | | | | | | | | | | | | |   alwaysRaise=[]+| | | | | | | | | | | | | | | | | | | |   freeRegs=[reg]+| | | | | | | | | | | | | | | | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| | | | | | | | | | | | | | | | | | | |   minReads=4+| | | | | | | | | | | | | | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | | | | | | | | | | | | | |   alwaysRaise=[]+| | | | | | | | | | | | | | | | | | | |   freeRegs=[reg]+| | | | | | | | | | | | | | | | | | | | call name+| | | | | | | | | | | | | | | | | | | |   minReads=4+| | | | | | | | | | | | | | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | | | | | | | | | | | | | |   alwaysRaise=[]+| | | | | | | | | | | | | | | | | | | |   freeRegs=[reg]+| | | | | | | | | | | | | | | | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| | | | | | | | | | | | | | | | | | | |   minReads=2+| | | | | | | | | | | | | | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | | | | | | | | | | | | | |   alwaysRaise=[]+| | | | | | | | | | | | | | | | | | | |   freeRegs=[reg]+| | | | | | | | | | | | | | | | | | | | pushValue (\x_0 -> x_0)+| | | | | | | | | | | | | | | | | | | |   minReads=2+| | | | | | | | | | | | | | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | | | | | | | | | | | | | |   alwaysRaise=[]+| | | | | | | | | | | | | | | | | | | |   freeRegs=[reg]+| | | | | | | | | | | | | | | | | | | | newRegister reg+| | | | | | | | | | | | | | | | | | | |   minReads=2+| | | | | | | | | | | | | | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | | | | | | | | | | | | | |   alwaysRaise=[]+| | | | | | | | | | | | | | | | | | | |   freeRegs=[reg]+| | | | | | | | | | | | | | | | | | | | iter loop+| | | | | | | | | | | | | | | | | | | |   minReads=2+| | | | | | | | | | | | | | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | | | | | | | | | | | | | |   alwaysRaise=[]+| | | | | | | | | | | | | | | | | | | |   freeRegs=[reg,reg]+| | | | | | | | | | | | | | | | | | | | | <ok>+| | | | | | | | | | | | | | | | | | | | | | pushValue (\x_0 -> \x_1 -> \x_2 -> x_0 x_2)+| | | | | | | | | | | | | | | | | | | | | |   minReads=4+| | | | | | | | | | | | | | | | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | | | | | | | | | | | | | | | |   alwaysRaise=[]+| | | | | | | | | | | | | | | | | | | | | |   freeRegs=[reg]+| | | | | | | | | | | | | | | | | | | | | | call name+| | | | | | | | | | | | | | | | | | | | | |   minReads=4+| | | | | | | | | | | | | | | | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | | | | | | | | | | | | | | | |   alwaysRaise=[]+| | | | | | | | | | | | | | | | | | | | | |   freeRegs=[reg]+| | | | | | | | | | | | | | | | | | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| | | | | | | | | | | | | | | | | | | | | |   minReads=4+| | | | | | | | | | | | | | | | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | | | | | | | | | | | | | | | |   alwaysRaise=[]+| | | | | | | | | | | | | | | | | | | | | |   freeRegs=[reg]+| | | | | | | | | | | | | | | | | | | | | | call name+| | | | | | | | | | | | | | | | | | | | | |   minReads=4+| | | | | | | | | | | | | | | | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | | | | | | | | | | | | | | | |   alwaysRaise=[]+| | | | | | | | | | | | | | | | | | | | | |   freeRegs=[reg]+| | | | | | | | | | | | | | | | | | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| | | | | | | | | | | | | | | | | | | | | |   minReads=2+| | | | | | | | | | | | | | | | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | | | | | | | | | | | | | | | |   alwaysRaise=[]+| | | | | | | | | | | | | | | | | | | | | |   freeRegs=[reg]+| | | | | | | | | | | | | | | | | | | | | | call name+| | | | | | | | | | | | | | | | | | | | | |   minReads=2+| | | | | | | | | | | | | | | | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | | | | | | | | | | | | | | | |   alwaysRaise=[]+| | | | | | | | | | | | | | | | | | | | | |   freeRegs=[reg]+| | | | | | | | | | | | | | | | | | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| | | | | | | | | | | | | | | | | | | | | |   minReads=0+| | | | | | | | | | | | | | | | | | | | | |   mayRaise=[]+| | | | | | | | | | | | | | | | | | | | | |   alwaysRaise=[]+| | | | | | | | | | | | | | | | | | | | | |   freeRegs=[reg]+| | | | | | | | | | | | | | | | | | | | | | readRegister reg+| | | | | | | | | | | | | | | | | | | | | |   minReads=0+| | | | | | | | | | | | | | | | | | | | | |   mayRaise=[]+| | | | | | | | | | | | | | | | | | | | | |   alwaysRaise=[]+| | | | | | | | | | | | | | | | | | | | | |   freeRegs=[reg]+| | | | | | | | | | | | | | | | | | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| | | | | | | | | | | | | | | | | | | | | |   minReads=0+| | | | | | | | | | | | | | | | | | | | | |   mayRaise=[]+| | | | | | | | | | | | | | | | | | | | | |   alwaysRaise=[]+| | | | | | | | | | | | | | | | | | | | | |   freeRegs=[reg]+| | | | | | | | | | | | | | | | | | | | | | writeRegister reg+| | | | | | | | | | | | | | | | | | | | | |   minReads=0+| | | | | | | | | | | | | | | | | | | | | |   mayRaise=[]+| | | | | | | | | | | | | | | | | | | | | |   alwaysRaise=[]+| | | | | | | | | | | | | | | | | | | | | |   freeRegs=[reg]+| | | | | | | | | | | | | | | | | | | | | | jump loop+| | | | | | | | | | | | | | | | | | | | | |   minReads=0+| | | | | | | | | | | | | | | | | | | | | |   mayRaise=[]+| | | | | | | | | | | | | | | | | | | | | |   alwaysRaise=[]+| | | | | | | | | | | | | | | | | | | | | |   freeRegs=[]+| | | | | | | | | | | | | | | | | | | | | <ko>+| | | | | | | | | | | | | | | | | | | | | | comment "raiseAgainIfConsumed"+| | | | | | | | | | | | | | | | | | | | | |   minReads=2+| | | | | | | | | | | | | | | | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | | | | | | | | | | | | | | | |   alwaysRaise=[]+| | | | | | | | | | | | | | | | | | | | | |   freeRegs=[reg,reg]+| | | | | | | | | | | | | | | | | | | | | | saveInput+| | | | | | | | | | | | | | | | | | | | | |   minReads=2+| | | | | | | | | | | | | | | | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | | | | | | | | | | | | | | | |   alwaysRaise=[]+| | | | | | | | | | | | | | | | | | | | | |   freeRegs=[reg,reg]+| | | | | | | | | | | | | | | | | | | | | | lift2Value (\(Data.Text.Internal.Text _ i_0 _) (Data.Text.Internal.Text _+| | | | | | | | | | | | | | | | | | | | | |                                                                j_1+| | | | | | | | | | | | | | | | | | | | | |                                                                _) -> i_0 GHC.Classes.== j_1)+| | | | | | | | | | | | | | | | | | | | | |   minReads=2+| | | | | | | | | | | | | | | | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | | | | | | | | | | | | | | | |   alwaysRaise=[]+| | | | | | | | | | | | | | | | | | | | | |   freeRegs=[reg,reg]+| | | | | | | | | | | | | | | | | | | | | | choicesBranch+| | | | | | | | | | | | | | | | | | | | | |   minReads=2+| | | | | | | | | | | | | | | | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | | | | | | | | | | | | | | | |   alwaysRaise=[]+| | | | | | | | | | | | | | | | | | | | | |   freeRegs=[reg,reg]+| | | | | | | | | | | | | | | | | | | | | | | <branch (\x_0 -> x_0)>+| | | | | | | | | | | | | | | | | | | | | | | | readRegister reg+| | | | | | | | | | | | | | | | | | | | | | | |   minReads=2+| | | | | | | | | | | | | | | | | | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | | | | | | | | | | | | | | | | | |   alwaysRaise=[]+| | | | | | | | | | | | | | | | | | | | | | | |   freeRegs=[reg,reg]+| | | | | | | | | | | | | | | | | | | | | | | | call name+| | | | | | | | | | | | | | | | | | | | | | | |   minReads=2+| | | | | | | | | | | | | | | | | | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | | | | | | | | | | | | | | | | | |   alwaysRaise=[]+| | | | | | | | | | | | | | | | | | | | | | | |   freeRegs=[reg]+| | | | | | | | | | | | | | | | | | | | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| | | | | | | | | | | | | | | | | | | | | | | |   minReads=2+| | | | | | | | | | | | | | | | | | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | | | | | | | | | | | | | | | | | |   alwaysRaise=[]+| | | | | | | | | | | | | | | | | | | | | | | |   freeRegs=[reg]+| | | | | | | | | | | | | | | | | | | | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| | | | | | | | | | | | | | | | | | | | | | | |   minReads=2+| | | | | | | | | | | | | | | | | | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | | | | | | | | | | | | | | | | | |   alwaysRaise=[]+| | | | | | | | | | | | | | | | | | | | | | | |   freeRegs=[reg]+| | | | | | | | | | | | | | | | | | | | | | | | call name+| | | | | | | | | | | | | | | | | | | | | | | |   minReads=2+| | | | | | | | | | | | | | | | | | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | | | | | | | | | | | | | | | | | |   alwaysRaise=[]+| | | | | | | | | | | | | | | | | | | | | | | |   freeRegs=[reg]+| | | | | | | | | | | | | | | | | | | | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| | | | | | | | | | | | | | | | | | | | | | | |   minReads=2+| | | | | | | | | | | | | | | | | | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | | | | | | | | | | | | | | | | | |   alwaysRaise=[]+| | | | | | | | | | | | | | | | | | | | | | | |   freeRegs=[reg]+| | | | | | | | | | | | | | | | | | | | | | | | call name+| | | | | | | | | | | | | | | | | | | | | | | |   minReads=2+| | | | | | | | | | | | | | | | | | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | | | | | | | | | | | | | | | | | |   alwaysRaise=[]+| | | | | | | | | | | | | | | | | | | | | | | |   freeRegs=[reg]+| | | | | | | | | | | | | | | | | | | | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| | | | | | | | | | | | | | | | | | | | | | | |   minReads=0+| | | | | | | | | | | | | | | | | | | | | | | |   mayRaise=[]+| | | | | | | | | | | | | | | | | | | | | | | |   alwaysRaise=[]+| | | | | | | | | | | | | | | | | | | | | | | |   freeRegs=[reg]+| | | | | | | | | | | | | | | | | | | | | | | | commit ExceptionFailure+| | | | | | | | | | | | | | | | | | | | | | | |   minReads=0+| | | | | | | | | | | | | | | | | | | | | | | |   mayRaise=[]+| | | | | | | | | | | | | | | | | | | | | | | |   alwaysRaise=[]+| | | | | | | | | | | | | | | | | | | | | | | |   freeRegs=[reg]+| | | | | | | | | | | | | | | | | | | | | | | | commit ExceptionFailure+| | | | | | | | | | | | | | | | | | | | | | | |   minReads=0+| | | | | | | | | | | | | | | | | | | | | | | |   mayRaise=[]+| | | | | | | | | | | | | | | | | | | | | | | |   alwaysRaise=[]+| | | | | | | | | | | | | | | | | | | | | | | |   freeRegs=[reg]+| | | | | | | | | | | | | | | | | | | | | | | | refJoin join+| | | | | | | | | | | | | | | | | | | | | | | |   minReads=0+| | | | | | | | | | | | | | | | | | | | | | | |   mayRaise=[]+| | | | | | | | | | | | | | | | | | | | | | | |   alwaysRaise=[]+| | | | | | | | | | | | | | | | | | | | | | | |   freeRegs=[reg]+| | | | | | | | | | | | | | | | | | | | | | | <default>+| | | | | | | | | | | | | | | | | | | | | | | | fail []+| | | | | | | | | | | | | | | | | | | | | | | |   minReads=0+| | | | | | | | | | | | | | | | | | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | | | | | | | | | | | | | | | | | |   alwaysRaise=[ExceptionFailure]+| | | | | | | | | | | | | | | | | | | | | | | |   freeRegs=[]+| | | | | | | | | | | | | | | | | | | <default>+| | | | | | | | | | | | | | | | | | | | fail []+| | | | | | | | | | | | | | | | | | | |   minReads=0+| | | | | | | | | | | | | | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | | | | | | | | | | | | | |   alwaysRaise=[ExceptionFailure]+| | | | | | | | | | | | | | | | | | | |   freeRegs=[]+| | | | | | | | | | | | | | | catch ExceptionFailure+| | | | | | | | | | | | | | |   minReads=8+| | | | | | | | | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | | | | | | | | |   alwaysRaise=[]+| | | | | | | | | | | | | | |   freeRegs=[reg]+| | | | | | | | | | | | | | | | <catchScope>+| | | | | | | | | | | | | | | | | pushValue (\x_0 -> \x_1 -> GHC.Tuple.())+| | | | | | | | | | | | | | | | |   minReads=11+| | | | | | | | | | | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | | | | | | | | | | |   alwaysRaise=[]+| | | | | | | | | | | | | | | | |   freeRegs=[reg]+| | | | | | | | | | | | | | | | | catch ExceptionFailure+| | | | | | | | | | | | | | | | |   minReads=11+| | | | | | | | | | | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | | | | | | | | | | |   alwaysRaise=[]+| | | | | | | | | | | | | | | | |   freeRegs=[reg]+| | | | | | | | | | | | | | | | | | <catchScope>+| | | | | | | | | | | | | | | | | | | pushValue (\x_0 -> \x_1 -> \x_2 -> (GHC.Types.:) 'v' ((GHC.Types.:) 'a' ((GHC.Types.:) 'r' GHC.Types.[])))+| | | | | | | | | | | | | | | | | | |   minReads=11+| | | | | | | | | | | | | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | | | | | | | | | | | | |   alwaysRaise=[]+| | | | | | | | | | | | | | | | | | |   freeRegs=[reg]+| | | | | | | | | | | | | | | | | | | comment "satisfy ((GHC.Classes.==) 'v')"+| | | | | | | | | | | | | | | | | | |   minReads=11+| | | | | | | | | | | | | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | | | | | | | | | | | | |   alwaysRaise=[]+| | | | | | | | | | | | | | | | | | |   freeRegs=[reg]+| | | | | | | | | | | | | | | | | | | read ((GHC.Classes.==) 'v')+| | | | | | | | | | | | | | | | | | |   minReads=11+| | | | | | | | | | | | | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | | | | | | | | | | | | |   alwaysRaise=[]+| | | | | | | | | | | | | | | | | | |   freeRegs=[reg]+| | | | | | | | | | | | | | | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| | | | | | | | | | | | | | | | | | |   minReads=10+| | | | | | | | | | | | | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | | | | | | | | | | | | |   alwaysRaise=[]+| | | | | | | | | | | | | | | | | | |   freeRegs=[reg]+| | | | | | | | | | | | | | | | | | | comment "satisfy ((GHC.Classes.==) 'a')"+| | | | | | | | | | | | | | | | | | |   minReads=10+| | | | | | | | | | | | | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | | | | | | | | | | | | |   alwaysRaise=[]+| | | | | | | | | | | | | | | | | | |   freeRegs=[reg]+| | | | | | | | | | | | | | | | | | | read ((GHC.Classes.==) 'a')+| | | | | | | | | | | | | | | | | | |   minReads=10+| | | | | | | | | | | | | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | | | | | | | | | | | | |   alwaysRaise=[]+| | | | | | | | | | | | | | | | | | |   freeRegs=[reg]+| | | | | | | | | | | | | | | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| | | | | | | | | | | | | | | | | | |   minReads=9+| | | | | | | | | | | | | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | | | | | | | | | | | | |   alwaysRaise=[]+| | | | | | | | | | | | | | | | | | |   freeRegs=[reg]+| | | | | | | | | | | | | | | | | | | comment "satisfy ((GHC.Classes.==) 'r')"+| | | | | | | | | | | | | | | | | | |   minReads=9+| | | | | | | | | | | | | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | | | | | | | | | | | | |   alwaysRaise=[]+| | | | | | | | | | | | | | | | | | |   freeRegs=[reg]+| | | | | | | | | | | | | | | | | | | read ((GHC.Classes.==) 'r')+| | | | | | | | | | | | | | | | | | |   minReads=9+| | | | | | | | | | | | | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | | | | | | | | | | | | |   alwaysRaise=[]+| | | | | | | | | | | | | | | | | | |   freeRegs=[reg]+| | | | | | | | | | | | | | | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| | | | | | | | | | | | | | | | | | |   minReads=8+| | | | | | | | | | | | | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | | | | | | | | | | | | |   alwaysRaise=[]+| | | | | | | | | | | | | | | | | | |   freeRegs=[reg]+| | | | | | | | | | | | | | | | | | | commit ExceptionFailure+| | | | | | | | | | | | | | | | | | |   minReads=8+| | | | | | | | | | | | | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | | | | | | | | | | | | |   alwaysRaise=[]+| | | | | | | | | | | | | | | | | | |   freeRegs=[reg]+| | | | | | | | | | | | | | | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| | | | | | | | | | | | | | | | | | |   minReads=8+| | | | | | | | | | | | | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | | | | | | | | | | | | |   alwaysRaise=[]+| | | | | | | | | | | | | | | | | | |   freeRegs=[reg]+| | | | | | | | | | | | | | | | | | | call name+| | | | | | | | | | | | | | | | | | |   minReads=8+| | | | | | | | | | | | | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | | | | | | | | | | | | |   alwaysRaise=[]+| | | | | | | | | | | | | | | | | | |   freeRegs=[reg]+| | | | | | | | | | | | | | | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| | | | | | | | | | | | | | | | | | |   minReads=8+| | | | | | | | | | | | | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | | | | | | | | | | | | |   alwaysRaise=[]+| | | | | | | | | | | | | | | | | | |   freeRegs=[reg]+| | | | | | | | | | | | | | | | | | | commit ExceptionFailure+| | | | | | | | | | | | | | | | | | |   minReads=8+| | | | | | | | | | | | | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | | | | | | | | | | | | |   alwaysRaise=[]+| | | | | | | | | | | | | | | | | | |   freeRegs=[reg]+| | | | | | | | | | | | | | | | | | | refJoin join+| | | | | | | | | | | | | | | | | | |   minReads=8+| | | | | | | | | | | | | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | | | | | | | | | | | | |   alwaysRaise=[]+| | | | | | | | | | | | | | | | | | |   freeRegs=[reg]+| | | | | | | | | | | | | | | | | | <onException ExceptionFailure>+| | | | | | | | | | | | | | | | | | | loadInput+| | | | | | | | | | | | | | | | | | |   minReads=0+| | | | | | | | | | | | | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | | | | | | | | | | | | |   alwaysRaise=[ExceptionFailure]+| | | | | | | | | | | | | | | | | | |   freeRegs=[]+| | | | | | | | | | | | | | | | | | | fail []+| | | | | | | | | | | | | | | | | | |   minReads=0+| | | | | | | | | | | | | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | | | | | | | | | | | | |   alwaysRaise=[ExceptionFailure]+| | | | | | | | | | | | | | | | | | |   freeRegs=[]+| | | | | | | | | | | | | | | | <onException ExceptionFailure>+| | | | | | | | | | | | | | | | | comment "raiseAgainIfConsumed"+| | | | | | | | | | | | | | | | |   minReads=8+| | | | | | | | | | | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | | | | | | | | | | |   alwaysRaise=[]+| | | | | | | | | | | | | | | | |   freeRegs=[reg]+| | | | | | | | | | | | | | | | | saveInput+| | | | | | | | | | | | | | | | |   minReads=8+| | | | | | | | | | | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | | | | | | | | | | |   alwaysRaise=[]+| | | | | | | | | | | | | | | | |   freeRegs=[reg]+| | | | | | | | | | | | | | | | | lift2Value (\(Data.Text.Internal.Text _ i_0 _) (Data.Text.Internal.Text _+| | | | | | | | | | | | | | | | |                                                                j_1+| | | | | | | | | | | | | | | | |                                                                _) -> i_0 GHC.Classes.== j_1)+| | | | | | | | | | | | | | | | |   minReads=8+| | | | | | | | | | | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | | | | | | | | | | |   alwaysRaise=[]+| | | | | | | | | | | | | | | | |   freeRegs=[reg]+| | | | | | | | | | | | | | | | | choicesBranch+| | | | | | | | | | | | | | | | |   minReads=8+| | | | | | | | | | | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | | | | | | | | | | |   alwaysRaise=[]+| | | | | | | | | | | | | | | | |   freeRegs=[reg]+| | | | | | | | | | | | | | | | | | <branch (\x_0 -> x_0)>+| | | | | | | | | | | | | | | | | | | call name+| | | | | | | | | | | | | | | | | | |   minReads=8+| | | | | | | | | | | | | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | | | | | | | | | | | | |   alwaysRaise=[]+| | | | | | | | | | | | | | | | | | |   freeRegs=[reg]+| | | | | | | | | | | | | | | | | | | refJoin join+| | | | | | | | | | | | | | | | | | |   minReads=8+| | | | | | | | | | | | | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | | | | | | | | | | | | |   alwaysRaise=[]+| | | | | | | | | | | | | | | | | | |   freeRegs=[reg]+| | | | | | | | | | | | | | | | | | <default>+| | | | | | | | | | | | | | | | | | | fail []+| | | | | | | | | | | | | | | | | | |   minReads=0+| | | | | | | | | | | | | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | | | | | | | | | | | | |   alwaysRaise=[ExceptionFailure]+| | | | | | | | | | | | | | | | | | |   freeRegs=[]+| | | | | | | | | | | | | | <onException ExceptionFailure>+| | | | | | | | | | | | | | | loadInput+| | | | | | | | | | | | | | |   minReads=0+| | | | | | | | | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | | | | | | | | |   alwaysRaise=[ExceptionFailure]+| | | | | | | | | | | | | | |   freeRegs=[]+| | | | | | | | | | | | | | | fail []+| | | | | | | | | | | | | | |   minReads=0+| | | | | | | | | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | | | | | | | | |   alwaysRaise=[ExceptionFailure]+| | | | | | | | | | | | | | |   freeRegs=[]+| | | | | | | | | | | | <onException ExceptionFailure>+| | | | | | | | | | | | | comment "raiseAgainIfConsumed"+| | | | | | | | | | | | |   minReads=4+| | | | | | | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | | | | | | |   alwaysRaise=[]+| | | | | | | | | | | | |   freeRegs=[reg]+| | | | | | | | | | | | | saveInput+| | | | | | | | | | | | |   minReads=4+| | | | | | | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | | | | | | |   alwaysRaise=[]+| | | | | | | | | | | | |   freeRegs=[reg]+| | | | | | | | | | | | | lift2Value (\(Data.Text.Internal.Text _ i_0 _) (Data.Text.Internal.Text _+| | | | | | | | | | | | |                                                                j_1+| | | | | | | | | | | | |                                                                _) -> i_0 GHC.Classes.== j_1)+| | | | | | | | | | | | |   minReads=4+| | | | | | | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | | | | | | |   alwaysRaise=[]+| | | | | | | | | | | | |   freeRegs=[reg]+| | | | | | | | | | | | | choicesBranch+| | | | | | | | | | | | |   minReads=4+| | | | | | | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | | | | | | |   alwaysRaise=[]+| | | | | | | | | | | | |   freeRegs=[reg]+| | | | | | | | | | | | | | <branch (\x_0 -> x_0)>+| | | | | | | | | | | | | | | pushValue (\x_0 -> \x_1 -> x_0)+| | | | | | | | | | | | | | |   minReads=4+| | | | | | | | | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | | | | | | | | |   alwaysRaise=[]+| | | | | | | | | | | | | | |   freeRegs=[reg]+| | | | | | | | | | | | | | | call name+| | | | | | | | | | | | | | |   minReads=4+| | | | | | | | | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | | | | | | | | |   alwaysRaise=[]+| | | | | | | | | | | | | | |   freeRegs=[reg]+| | | | | | | | | | | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| | | | | | | | | | | | | | |   minReads=2+| | | | | | | | | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | | | | | | | | |   alwaysRaise=[]+| | | | | | | | | | | | | | |   freeRegs=[reg]+| | | | | | | | | | | | | | | call name+| | | | | | | | | | | | | | |   minReads=2+| | | | | | | | | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | | | | | | | | |   alwaysRaise=[]+| | | | | | | | | | | | | | |   freeRegs=[reg]+| | | | | | | | | | | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| | | | | | | | | | | | | | |   minReads=0+| | | | | | | | | | | | | | |   mayRaise=[]+| | | | | | | | | | | | | | |   alwaysRaise=[]+| | | | | | | | | | | | | | |   freeRegs=[reg]+| | | | | | | | | | | | | | | refJoin join+| | | | | | | | | | | | | | |   minReads=0+| | | | | | | | | | | | | | |   mayRaise=[]+| | | | | | | | | | | | | | |   alwaysRaise=[]+| | | | | | | | | | | | | | |   freeRegs=[reg]+| | | | | | | | | | | | | | <default>+| | | | | | | | | | | | | | | fail []+| | | | | | | | | | | | | | |   minReads=0+| | | | | | | | | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | | | | | | | | |   alwaysRaise=[ExceptionFailure]+| | | | | | | | | | | | | | |   freeRegs=[]+| | | | | | | | | | <default>+| | | | | | | | | | | fail []+| | | | | | | | | | |   minReads=0+| | | | | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | | | | |   alwaysRaise=[ExceptionFailure]+| | | | | | | | | | |   freeRegs=[]+| | | | | | <default>+| | | | | | | fail []+| | | | | | |   minReads=0+| | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | |   alwaysRaise=[ExceptionFailure]+| | | | | | |   freeRegs=[]+| | <ko>+| | | comment "raiseAgainIfConsumed"+| | |   minReads=2+| | |   mayRaise=[ExceptionFailure]+| | |   alwaysRaise=[]+| | |   freeRegs=[reg]+| | | saveInput+| | |   minReads=2+| | |   mayRaise=[ExceptionFailure]+| | |   alwaysRaise=[]+| | |   freeRegs=[reg]+| | | lift2Value (\(Data.Text.Internal.Text _ i_0 _) (Data.Text.Internal.Text _+| | |                                                                j_1+| | |                                                                _) -> i_0 GHC.Classes.== j_1)+| | |   minReads=2+| | |   mayRaise=[ExceptionFailure]+| | |   alwaysRaise=[]+| | |   freeRegs=[reg]+| | | choicesBranch+| | |   minReads=2+| | |   mayRaise=[ExceptionFailure]+| | |   alwaysRaise=[]+| | |   freeRegs=[reg]+| | | | <branch (\x_0 -> x_0)>+| | | | | readRegister reg+| | | | |   minReads=2+| | | | |   mayRaise=[ExceptionFailure]+| | | | |   alwaysRaise=[]+| | | | |   freeRegs=[reg]+| | | | | call name+| | | | |   minReads=2+| | | | |   mayRaise=[ExceptionFailure]+| | | | |   alwaysRaise=[]+| | | | |   freeRegs=[]+| | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| | | | |   minReads=2+| | | | |   mayRaise=[ExceptionFailure]+| | | | |   alwaysRaise=[]+| | | | |   freeRegs=[]+| | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| | | | |   minReads=2+| | | | |   mayRaise=[ExceptionFailure]+| | | | |   alwaysRaise=[]+| | | | |   freeRegs=[]+| | | | | call name+| | | | |   minReads=2+| | | | |   mayRaise=[ExceptionFailure]+| | | | |   alwaysRaise=[]+| | | | |   freeRegs=[]+| | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| | | | |   minReads=2+| | | | |   mayRaise=[ExceptionFailure]+| | | | |   alwaysRaise=[]+| | | | |   freeRegs=[]+| | | | | comment "satisfy ((GHC.Classes.==) '}')"+| | | | |   minReads=2+| | | | |   mayRaise=[ExceptionFailure]+| | | | |   alwaysRaise=[]+| | | | |   freeRegs=[]+| | | | | read ((GHC.Classes.==) '}')+| | | | |   minReads=2+| | | | |   mayRaise=[ExceptionFailure]+| | | | |   alwaysRaise=[]+| | | | |   freeRegs=[]+| | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| | | | |   minReads=1+| | | | |   mayRaise=[ExceptionFailure]+| | | | |   alwaysRaise=[]+| | | | |   freeRegs=[]+| | | | | call name+| | | | |   minReads=1+| | | | |   mayRaise=[ExceptionFailure]+| | | | |   alwaysRaise=[]+| | | | |   freeRegs=[]+| | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| | | | |   minReads=0+| | | | |   mayRaise=[]+| | | | |   alwaysRaise=[]+| | | | |   freeRegs=[]+| | | | | ret+| | | | |   minReads=0+| | | | |   mayRaise=[]+| | | | |   alwaysRaise=[]+| | | | |   freeRegs=[]+| | | | <default>+| | | | | fail []+| | | | |   minReads=0+| | | | |   mayRaise=[ExceptionFailure]+| | | | |   alwaysRaise=[ExceptionFailure]+| | | | |   freeRegs=[]+let name+  minReads=5+  mayRaise=[ExceptionFailure]+  alwaysRaise=[]+  freeRegs=[]+| pushValue (\x_0 -> \x_1 -> \x_2 -> \x_3 -> \x_4 -> \x_5 -> GHC.Tuple.())+|   minReads=5+|   mayRaise=[ExceptionFailure]+|   alwaysRaise=[]+|   freeRegs=[]+| comment "satisfy ((GHC.Classes.==) '[')"+|   minReads=5+|   mayRaise=[ExceptionFailure]+|   alwaysRaise=[]+|   freeRegs=[]+| read ((GHC.Classes.==) '[')+|   minReads=5+|   mayRaise=[ExceptionFailure]+|   alwaysRaise=[]+|   freeRegs=[]+| lift2Value (\x_0 -> \x_1 -> x_0 x_1)+|   minReads=4+|   mayRaise=[ExceptionFailure]+|   alwaysRaise=[]+|   freeRegs=[]+| call name+|   minReads=4+|   mayRaise=[ExceptionFailure]+|   alwaysRaise=[]+|   freeRegs=[]+| lift2Value (\x_0 -> \x_1 -> x_0 x_1)+|   minReads=3+|   mayRaise=[ExceptionFailure]+|   alwaysRaise=[]+|   freeRegs=[]+| call name+|   minReads=3+|   mayRaise=[ExceptionFailure]+|   alwaysRaise=[]+|   freeRegs=[]+| lift2Value (\x_0 -> \x_1 -> x_0 x_1)+|   minReads=2+|   mayRaise=[ExceptionFailure]+|   alwaysRaise=[]+|   freeRegs=[]+| pushValue (\x_0 -> x_0)+|   minReads=2+|   mayRaise=[ExceptionFailure]+|   alwaysRaise=[]+|   freeRegs=[]+| newRegister reg+|   minReads=2+|   mayRaise=[ExceptionFailure]+|   alwaysRaise=[]+|   freeRegs=[]+| iter loop+|   minReads=2+|   mayRaise=[ExceptionFailure]+|   alwaysRaise=[]+|   freeRegs=[reg]+| | <ok>+| | | pushValue (\x_0 -> \x_1 -> x_1)+| | |   minReads=1+| | |   mayRaise=[ExceptionFailure]+| | |   alwaysRaise=[]+| | |   freeRegs=[reg]+| | | call name+| | |   minReads=1+| | |   mayRaise=[ExceptionFailure]+| | |   alwaysRaise=[]+| | |   freeRegs=[reg]+| | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| | |   minReads=0+| | |   mayRaise=[]+| | |   alwaysRaise=[]+| | |   freeRegs=[reg]+| | | readRegister reg+| | |   minReads=0+| | |   mayRaise=[]+| | |   alwaysRaise=[]+| | |   freeRegs=[reg]+| | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| | |   minReads=0+| | |   mayRaise=[]+| | |   alwaysRaise=[]+| | |   freeRegs=[reg]+| | | writeRegister reg+| | |   minReads=0+| | |   mayRaise=[]+| | |   alwaysRaise=[]+| | |   freeRegs=[reg]+| | | jump loop+| | |   minReads=0+| | |   mayRaise=[]+| | |   alwaysRaise=[]+| | |   freeRegs=[]+| | <ko>+| | | comment "raiseAgainIfConsumed"+| | |   minReads=2+| | |   mayRaise=[ExceptionFailure]+| | |   alwaysRaise=[]+| | |   freeRegs=[reg]+| | | saveInput+| | |   minReads=2+| | |   mayRaise=[ExceptionFailure]+| | |   alwaysRaise=[]+| | |   freeRegs=[reg]+| | | lift2Value (\(Data.Text.Internal.Text _ i_0 _) (Data.Text.Internal.Text _+| | |                                                                j_1+| | |                                                                _) -> i_0 GHC.Classes.== j_1)+| | |   minReads=2+| | |   mayRaise=[ExceptionFailure]+| | |   alwaysRaise=[]+| | |   freeRegs=[reg]+| | | choicesBranch+| | |   minReads=2+| | |   mayRaise=[ExceptionFailure]+| | |   alwaysRaise=[]+| | |   freeRegs=[reg]+| | | | <branch (\x_0 -> x_0)>+| | | | | readRegister reg+| | | | |   minReads=2+| | | | |   mayRaise=[ExceptionFailure]+| | | | |   alwaysRaise=[]+| | | | |   freeRegs=[reg]+| | | | | pushValue GHC.Tuple.()+| | | | |   minReads=2+| | | | |   mayRaise=[ExceptionFailure]+| | | | |   alwaysRaise=[]+| | | | |   freeRegs=[]+| | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| | | | |   minReads=2+| | | | |   mayRaise=[ExceptionFailure]+| | | | |   alwaysRaise=[]+| | | | |   freeRegs=[]+| | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| | | | |   minReads=2+| | | | |   mayRaise=[ExceptionFailure]+| | | | |   alwaysRaise=[]+| | | | |   freeRegs=[]+| | | | | comment "satisfy ((GHC.Classes.==) ']')"+| | | | |   minReads=2+| | | | |   mayRaise=[ExceptionFailure]+| | | | |   alwaysRaise=[]+| | | | |   freeRegs=[]+| | | | | read ((GHC.Classes.==) ']')+| | | | |   minReads=2+| | | | |   mayRaise=[ExceptionFailure]+| | | | |   alwaysRaise=[]+| | | | |   freeRegs=[]+| | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| | | | |   minReads=1+| | | | |   mayRaise=[ExceptionFailure]+| | | | |   alwaysRaise=[]+| | | | |   freeRegs=[]+| | | | | call name+| | | | |   minReads=1+| | | | |   mayRaise=[ExceptionFailure]+| | | | |   alwaysRaise=[]+| | | | |   freeRegs=[]+| | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| | | | |   minReads=0+| | | | |   mayRaise=[]+| | | | |   alwaysRaise=[]+| | | | |   freeRegs=[]+| | | | | ret+| | | | |   minReads=0+| | | | |   mayRaise=[]+| | | | |   alwaysRaise=[]+| | | | |   freeRegs=[]+| | | | <default>+| | | | | fail []+| | | | |   minReads=0+| | | | |   mayRaise=[ExceptionFailure]+| | | | |   alwaysRaise=[ExceptionFailure]+| | | | |   freeRegs=[]+pushValue (\x_0 -> \x_1 -> \x_2 -> \x_3 -> GHC.Show.show x_2)+  minReads=1+  mayRaise=[ExceptionFailure]+  alwaysRaise=[]+  freeRegs=[]+call name+  minReads=1+  mayRaise=[ExceptionFailure]+  alwaysRaise=[]+  freeRegs=[]+lift2Value (\x_0 -> \x_1 -> x_0 x_1)+  minReads=0+  mayRaise=[ExceptionFailure]+  alwaysRaise=[]+  freeRegs=[]+pushValue (\x_0 -> x_0)+  minReads=0+  mayRaise=[ExceptionFailure]+  alwaysRaise=[]+  freeRegs=[]+newRegister reg+  minReads=0+  mayRaise=[ExceptionFailure]+  alwaysRaise=[]+  freeRegs=[]+iter loop+  minReads=0+  mayRaise=[ExceptionFailure]+  alwaysRaise=[]+  freeRegs=[reg]+| <ok>+| | pushValue (\x_0 -> \x_1 -> \x_2 -> \x_3 -> \x_4 -> \x_5 -> \x_6 -> \x_7 -> \x_8 -> x_8)+| |   minReads=18+| |   mayRaise=[ExceptionFailure]+| |   alwaysRaise=[]+| |   freeRegs=[reg]+| | catch ExceptionFailure+| |   minReads=18+| |   mayRaise=[ExceptionFailure]+| |   alwaysRaise=[]+| |   freeRegs=[reg]+| | | <catchScope>+| | | | pushValue (\x_0 -> \x_1 -> \x_2 -> \x_3 -> \x_4 -> \x_5 -> \x_6 -> \x_7 -> (GHC.Types.:) 'f' ((GHC.Types.:) 'u' ((GHC.Types.:) 'n' ((GHC.Types.:) 'c' ((GHC.Types.:) 't' ((GHC.Types.:) 'i' ((GHC.Types.:) 'o' ((GHC.Types.:) 'n' GHC.Types.[]))))))))+| | | |   minReads=18+| | | |   mayRaise=[ExceptionFailure]+| | | |   alwaysRaise=[]+| | | |   freeRegs=[reg]+| | | | comment "satisfy ((GHC.Classes.==) 'f')"+| | | |   minReads=18+| | | |   mayRaise=[ExceptionFailure]+| | | |   alwaysRaise=[]+| | | |   freeRegs=[reg]+| | | | read ((GHC.Classes.==) 'f')+| | | |   minReads=18+| | | |   mayRaise=[ExceptionFailure]+| | | |   alwaysRaise=[]+| | | |   freeRegs=[reg]+| | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| | | |   minReads=17+| | | |   mayRaise=[ExceptionFailure]+| | | |   alwaysRaise=[]+| | | |   freeRegs=[reg]+| | | | comment "satisfy ((GHC.Classes.==) 'u')"+| | | |   minReads=17+| | | |   mayRaise=[ExceptionFailure]+| | | |   alwaysRaise=[]+| | | |   freeRegs=[reg]+| | | | read ((GHC.Classes.==) 'u')+| | | |   minReads=17+| | | |   mayRaise=[ExceptionFailure]+| | | |   alwaysRaise=[]+| | | |   freeRegs=[reg]+| | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| | | |   minReads=16+| | | |   mayRaise=[ExceptionFailure]+| | | |   alwaysRaise=[]+| | | |   freeRegs=[reg]+| | | | comment "satisfy ((GHC.Classes.==) 'n')"+| | | |   minReads=16+| | | |   mayRaise=[ExceptionFailure]+| | | |   alwaysRaise=[]+| | | |   freeRegs=[reg]+| | | | read ((GHC.Classes.==) 'n')+| | | |   minReads=16+| | | |   mayRaise=[ExceptionFailure]+| | | |   alwaysRaise=[]+| | | |   freeRegs=[reg]+| | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| | | |   minReads=15+| | | |   mayRaise=[ExceptionFailure]+| | | |   alwaysRaise=[]+| | | |   freeRegs=[reg]+| | | | comment "satisfy ((GHC.Classes.==) 'c')"+| | | |   minReads=15+| | | |   mayRaise=[ExceptionFailure]+| | | |   alwaysRaise=[]+| | | |   freeRegs=[reg]+| | | | read ((GHC.Classes.==) 'c')+| | | |   minReads=15+| | | |   mayRaise=[ExceptionFailure]+| | | |   alwaysRaise=[]+| | | |   freeRegs=[reg]+| | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| | | |   minReads=14+| | | |   mayRaise=[ExceptionFailure]+| | | |   alwaysRaise=[]+| | | |   freeRegs=[reg]+| | | | comment "satisfy ((GHC.Classes.==) 't')"+| | | |   minReads=14+| | | |   mayRaise=[ExceptionFailure]+| | | |   alwaysRaise=[]+| | | |   freeRegs=[reg]+| | | | read ((GHC.Classes.==) 't')+| | | |   minReads=14+| | | |   mayRaise=[ExceptionFailure]+| | | |   alwaysRaise=[]+| | | |   freeRegs=[reg]+| | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| | | |   minReads=13+| | | |   mayRaise=[ExceptionFailure]+| | | |   alwaysRaise=[]+| | | |   freeRegs=[reg]+| | | | comment "satisfy ((GHC.Classes.==) 'i')"+| | | |   minReads=13+| | | |   mayRaise=[ExceptionFailure]+| | | |   alwaysRaise=[]+| | | |   freeRegs=[reg]+| | | | read ((GHC.Classes.==) 'i')+| | | |   minReads=13+| | | |   mayRaise=[ExceptionFailure]+| | | |   alwaysRaise=[]+| | | |   freeRegs=[reg]+| | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| | | |   minReads=12+| | | |   mayRaise=[ExceptionFailure]+| | | |   alwaysRaise=[]+| | | |   freeRegs=[reg]+| | | | comment "satisfy ((GHC.Classes.==) 'o')"+| | | |   minReads=12+| | | |   mayRaise=[ExceptionFailure]+| | | |   alwaysRaise=[]+| | | |   freeRegs=[reg]+| | | | read ((GHC.Classes.==) 'o')+| | | |   minReads=12+| | | |   mayRaise=[ExceptionFailure]+| | | |   alwaysRaise=[]+| | | |   freeRegs=[reg]+| | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| | | |   minReads=11+| | | |   mayRaise=[ExceptionFailure]+| | | |   alwaysRaise=[]+| | | |   freeRegs=[reg]+| | | | comment "satisfy ((GHC.Classes.==) 'n')"+| | | |   minReads=11+| | | |   mayRaise=[ExceptionFailure]+| | | |   alwaysRaise=[]+| | | |   freeRegs=[reg]+| | | | read ((GHC.Classes.==) 'n')+| | | |   minReads=11+| | | |   mayRaise=[ExceptionFailure]+| | | |   alwaysRaise=[]+| | | |   freeRegs=[reg]+| | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| | | |   minReads=10+| | | |   mayRaise=[ExceptionFailure]+| | | |   alwaysRaise=[]+| | | |   freeRegs=[reg]+| | | | commit ExceptionFailure+| | | |   minReads=10+| | | |   mayRaise=[ExceptionFailure]+| | | |   alwaysRaise=[]+| | | |   freeRegs=[reg]+| | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| | | |   minReads=10+| | | |   mayRaise=[ExceptionFailure]+| | | |   alwaysRaise=[]+| | | |   freeRegs=[reg]+| | | | call name+| | | |   minReads=10+| | | |   mayRaise=[ExceptionFailure]+| | | |   alwaysRaise=[]+| | | |   freeRegs=[reg]+| | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| | | |   minReads=10+| | | |   mayRaise=[ExceptionFailure]+| | | |   alwaysRaise=[]+| | | |   freeRegs=[reg]+| | | | call name+| | | |   minReads=10+| | | |   mayRaise=[ExceptionFailure]+| | | |   alwaysRaise=[]+| | | |   freeRegs=[reg]+| | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| | | |   minReads=8+| | | |   mayRaise=[ExceptionFailure]+| | | |   alwaysRaise=[]+| | | |   freeRegs=[reg]+| | | | call name+| | | |   minReads=8+| | | |   mayRaise=[ExceptionFailure]+| | | |   alwaysRaise=[]+| | | |   freeRegs=[reg]+| | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| | | |   minReads=6+| | | |   mayRaise=[ExceptionFailure]+| | | |   alwaysRaise=[]+| | | |   freeRegs=[reg]+| | | | call name+| | | |   minReads=6+| | | |   mayRaise=[ExceptionFailure]+| | | |   alwaysRaise=[]+| | | |   freeRegs=[reg]+| | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| | | |   minReads=6+| | | |   mayRaise=[ExceptionFailure]+| | | |   alwaysRaise=[]+| | | |   freeRegs=[reg]+| | | | join join+| | | |   minReads=6+| | | |   mayRaise=[ExceptionFailure]+| | | |   alwaysRaise=[]+| | | |   freeRegs=[reg]+| | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| | | | |   minReads=6+| | | | |   mayRaise=[ExceptionFailure]+| | | | |   alwaysRaise=[]+| | | | |   freeRegs=[reg]+| | | | | call name+| | | | |   minReads=6+| | | | |   mayRaise=[ExceptionFailure]+| | | | |   alwaysRaise=[]+| | | | |   freeRegs=[reg]+| | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| | | | |   minReads=4+| | | | |   mayRaise=[ExceptionFailure]+| | | | |   alwaysRaise=[]+| | | | |   freeRegs=[reg]+| | | | | call name+| | | | |   minReads=4+| | | | |   mayRaise=[ExceptionFailure]+| | | | |   alwaysRaise=[]+| | | | |   freeRegs=[reg]+| | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| | | | |   minReads=0+| | | | |   mayRaise=[]+| | | | |   alwaysRaise=[]+| | | | |   freeRegs=[reg]+| | | | | readRegister reg+| | | | |   minReads=0+| | | | |   mayRaise=[]+| | | | |   alwaysRaise=[]+| | | | |   freeRegs=[reg]+| | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| | | | |   minReads=0+| | | | |   mayRaise=[]+| | | | |   alwaysRaise=[]+| | | | |   freeRegs=[reg]+| | | | | writeRegister reg+| | | | |   minReads=0+| | | | |   mayRaise=[]+| | | | |   alwaysRaise=[]+| | | | |   freeRegs=[reg]+| | | | | jump loop+| | | | |   minReads=0+| | | | |   mayRaise=[]+| | | | |   alwaysRaise=[]+| | | | |   freeRegs=[]+| | | | catch ExceptionFailure+| | | |   minReads=6+| | | |   mayRaise=[ExceptionFailure]+| | | |   alwaysRaise=[]+| | | |   freeRegs=[reg]+| | | | | <catchScope>+| | | | | | pushValue (\x_0 -> \x_1 -> \x_2 -> GHC.Tuple.())+| | | | | |   minReads=8+| | | | | |   mayRaise=[ExceptionFailure]+| | | | | |   alwaysRaise=[]+| | | | | |   freeRegs=[reg]+| | | | | | comment "satisfy ((GHC.Classes.==) ':')"+| | | | | |   minReads=8+| | | | | |   mayRaise=[ExceptionFailure]+| | | | | |   alwaysRaise=[]+| | | | | |   freeRegs=[reg]+| | | | | | read ((GHC.Classes.==) ':')+| | | | | |   minReads=8+| | | | | |   mayRaise=[ExceptionFailure]+| | | | | |   alwaysRaise=[]+| | | | | |   freeRegs=[reg]+| | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| | | | | |   minReads=7+| | | | | |   mayRaise=[ExceptionFailure]+| | | | | |   alwaysRaise=[]+| | | | | |   freeRegs=[reg]+| | | | | | call name+| | | | | |   minReads=7+| | | | | |   mayRaise=[ExceptionFailure]+| | | | | |   alwaysRaise=[]+| | | | | |   freeRegs=[reg]+| | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| | | | | |   minReads=6+| | | | | |   mayRaise=[ExceptionFailure]+| | | | | |   alwaysRaise=[]+| | | | | |   freeRegs=[reg]+| | | | | | call name+| | | | | |   minReads=6+| | | | | |   mayRaise=[ExceptionFailure]+| | | | | |   alwaysRaise=[]+| | | | | |   freeRegs=[reg]+| | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| | | | | |   minReads=6+| | | | | |   mayRaise=[ExceptionFailure]+| | | | | |   alwaysRaise=[]+| | | | | |   freeRegs=[reg]+| | | | | | commit ExceptionFailure+| | | | | |   minReads=6+| | | | | |   mayRaise=[ExceptionFailure]+| | | | | |   alwaysRaise=[]+| | | | | |   freeRegs=[reg]+| | | | | | refJoin join+| | | | | |   minReads=6+| | | | | |   mayRaise=[ExceptionFailure]+| | | | | |   alwaysRaise=[]+| | | | | |   freeRegs=[reg]+| | | | | <onException ExceptionFailure>+| | | | | | comment "raiseAgainIfConsumed"+| | | | | |   minReads=6+| | | | | |   mayRaise=[ExceptionFailure]+| | | | | |   alwaysRaise=[]+| | | | | |   freeRegs=[reg]+| | | | | | saveInput+| | | | | |   minReads=6+| | | | | |   mayRaise=[ExceptionFailure]+| | | | | |   alwaysRaise=[]+| | | | | |   freeRegs=[reg]+| | | | | | lift2Value (\(Data.Text.Internal.Text _ i_0 _) (Data.Text.Internal.Text _+| | | | | |                                                                j_1+| | | | | |                                                                _) -> i_0 GHC.Classes.== j_1)+| | | | | |   minReads=6+| | | | | |   mayRaise=[ExceptionFailure]+| | | | | |   alwaysRaise=[]+| | | | | |   freeRegs=[reg]+| | | | | | choicesBranch+| | | | | |   minReads=6+| | | | | |   mayRaise=[ExceptionFailure]+| | | | | |   alwaysRaise=[]+| | | | | |   freeRegs=[reg]+| | | | | | | <branch (\x_0 -> x_0)>+| | | | | | | | call name+| | | | | | | |   minReads=6+| | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | |   alwaysRaise=[]+| | | | | | | |   freeRegs=[reg]+| | | | | | | | refJoin join+| | | | | | | |   minReads=6+| | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | |   alwaysRaise=[]+| | | | | | | |   freeRegs=[reg]+| | | | | | | <default>+| | | | | | | | fail []+| | | | | | | |   minReads=0+| | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | |   alwaysRaise=[ExceptionFailure]+| | | | | | | |   freeRegs=[]+| | | <onException ExceptionFailure>+| | | | loadInput+| | | |   minReads=0+| | | |   mayRaise=[ExceptionFailure]+| | | |   alwaysRaise=[ExceptionFailure]+| | | |   freeRegs=[]+| | | | fail []+| | | |   minReads=0+| | | |   mayRaise=[ExceptionFailure]+| | | |   alwaysRaise=[ExceptionFailure]+| | | |   freeRegs=[]+| <ko>+| | comment "raiseAgainIfConsumed"+| |   minReads=0+| |   mayRaise=[ExceptionFailure]+| |   alwaysRaise=[]+| |   freeRegs=[reg]+| | saveInput+| |   minReads=0+| |   mayRaise=[ExceptionFailure]+| |   alwaysRaise=[]+| |   freeRegs=[reg]+| | lift2Value (\(Data.Text.Internal.Text _ i_0 _) (Data.Text.Internal.Text _+| |                                                                j_1+| |                                                                _) -> i_0 GHC.Classes.== j_1)+| |   minReads=0+| |   mayRaise=[ExceptionFailure]+| |   alwaysRaise=[]+| |   freeRegs=[reg]+| | choicesBranch+| |   minReads=0+| |   mayRaise=[ExceptionFailure]+| |   alwaysRaise=[]+| |   freeRegs=[reg]+| | | <branch (\x_0 -> x_0)>+| | | | readRegister reg+| | | |   minReads=0+| | | |   mayRaise=[ExceptionFailure]+| | | |   alwaysRaise=[]+| | | |   freeRegs=[reg]+| | | | call name+| | | |   minReads=0+| | | |   mayRaise=[ExceptionFailure]+| | | |   alwaysRaise=[]+| | | |   freeRegs=[]+| | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| | | |   minReads=0+| | | |   mayRaise=[ExceptionFailure]+| | | |   alwaysRaise=[]+| | | |   freeRegs=[]+| | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| | | |   minReads=0+| | | |   mayRaise=[ExceptionFailure]+| | | |   alwaysRaise=[]+| | | |   freeRegs=[]+| | | | call name+| | | |   minReads=0+| | | |   mayRaise=[ExceptionFailure]+| | | |   alwaysRaise=[]+| | | |   freeRegs=[]+| | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| | | |   minReads=0+| | | |   mayRaise=[ExceptionFailure]+| | | |   alwaysRaise=[]+| | | |   freeRegs=[]+| | | | join join+| | | |   minReads=0+| | | |   mayRaise=[]+| | | |   alwaysRaise=[]+| | | |   freeRegs=[]+| | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| | | | |   minReads=0+| | | | |   mayRaise=[]+| | | | |   alwaysRaise=[]+| | | | |   freeRegs=[]+| | | | | ret+| | | | |   minReads=0+| | | | |   mayRaise=[]+| | | | |   alwaysRaise=[]+| | | | |   freeRegs=[]+| | | | catch ExceptionFailure+| | | |   minReads=0+| | | |   mayRaise=[ExceptionFailure]+| | | |   alwaysRaise=[]+| | | |   freeRegs=[]+| | | | | <catchScope>+| | | | | | comment "negLook"+| | | | | |   minReads=0+| | | | | |   mayRaise=[]+| | | | | |   alwaysRaise=[]+| | | | | |   freeRegs=[]+| | | | | | catch ExceptionFailure+| | | | | |   minReads=0+| | | | | |   mayRaise=[]+| | | | | |   alwaysRaise=[]+| | | | | |   freeRegs=[]+| | | | | | | <catchScope>+| | | | | | | | comment "negLook.ahead"+| | | | | | | |   minReads=1+| | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | |   alwaysRaise=[ExceptionFailure]+| | | | | | | |   freeRegs=[]+| | | | | | | | saveInput+| | | | | | | |   minReads=1+| | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | |   alwaysRaise=[ExceptionFailure]+| | | | | | | |   freeRegs=[]+| | | | | | | | comment "satisfy ((\\x_0 -> \\x_1 -> x_0) GHC.Types.True)"+| | | | | | | |   minReads=1+| | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | |   alwaysRaise=[ExceptionFailure]+| | | | | | | |   freeRegs=[]+| | | | | | | | read (\x_0 -> GHC.Types.True)+| | | | | | | |   minReads=1+| | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | |   alwaysRaise=[ExceptionFailure]+| | | | | | | |   freeRegs=[]+| | | | | | | | popValue+| | | | | | | |   minReads=0+| | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | |   alwaysRaise=[ExceptionFailure]+| | | | | | | |   freeRegs=[]+| | | | | | | | commit ExceptionFailure+| | | | | | | |   minReads=0+| | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | |   alwaysRaise=[ExceptionFailure]+| | | | | | | |   freeRegs=[]+| | | | | | | | loadInput+| | | | | | | |   minReads=0+| | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | |   alwaysRaise=[ExceptionFailure]+| | | | | | | |   freeRegs=[]+| | | | | | | | fail []+| | | | | | | |   minReads=0+| | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | |   alwaysRaise=[ExceptionFailure]+| | | | | | | |   freeRegs=[]+| | | | | | | <onException ExceptionFailure>+| | | | | | | | comment "negLook.reset"+| | | | | | | |   minReads=0+| | | | | | | |   mayRaise=[]+| | | | | | | |   alwaysRaise=[]+| | | | | | | |   freeRegs=[]+| | | | | | | | loadInput+| | | | | | | |   minReads=0+| | | | | | | |   mayRaise=[]+| | | | | | | |   alwaysRaise=[]+| | | | | | | |   freeRegs=[]+| | | | | | | | pushValue GHC.Tuple.()+| | | | | | | |   minReads=0+| | | | | | | |   mayRaise=[]+| | | | | | | |   alwaysRaise=[]+| | | | | | | |   freeRegs=[]+| | | | | | | | commit ExceptionFailure+| | | | | | | |   minReads=0+| | | | | | | |   mayRaise=[]+| | | | | | | |   alwaysRaise=[]+| | | | | | | |   freeRegs=[]+| | | | | | | | refJoin join+| | | | | | | |   minReads=0+| | | | | | | |   mayRaise=[]+| | | | | | | |   alwaysRaise=[]+| | | | | | | |   freeRegs=[]+| | | | | <onException ExceptionFailure>+| | | | | | comment "raiseAgainIfConsumed"+| | | | | |   minReads=0+| | | | | |   mayRaise=[ExceptionFailure]+| | | | | |   alwaysRaise=[]+| | | | | |   freeRegs=[]+| | | | | | saveInput+| | | | | |   minReads=0+| | | | | |   mayRaise=[ExceptionFailure]+| | | | | |   alwaysRaise=[]+| | | | | |   freeRegs=[]+| | | | | | lift2Value (\(Data.Text.Internal.Text _ i_0 _) (Data.Text.Internal.Text _+| | | | | |                                                                j_1+| | | | | |                                                                _) -> i_0 GHC.Classes.== j_1)+| | | | | |   minReads=0+| | | | | |   mayRaise=[ExceptionFailure]+| | | | | |   alwaysRaise=[]+| | | | | |   freeRegs=[]+| | | | | | choicesBranch+| | | | | |   minReads=0+| | | | | |   mayRaise=[ExceptionFailure]+| | | | | |   alwaysRaise=[]+| | | | | |   freeRegs=[]+| | | | | | | <branch (\x_0 -> x_0)>+| | | | | | | | comment "eof.fail"+| | | | | | | |   minReads=0+| | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | |   alwaysRaise=[ExceptionFailure]+| | | | | | | |   freeRegs=[]+| | | | | | | | fail [FailureEnd]+| | | | | | | |   minReads=0+| | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | |   alwaysRaise=[ExceptionFailure]+| | | | | | | |   freeRegs=[]+| | | | | | | <default>+| | | | | | | | fail []+| | | | | | | |   minReads=0+| | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | |   alwaysRaise=[ExceptionFailure]+| | | | | | | |   freeRegs=[]+| | | <default>+| | | | fail []+| | | |   minReads=0+| | | |   mayRaise=[ExceptionFailure]+| | | |   alwaysRaise=[ExceptionFailure]+| | | |   freeRegs=[]
+ tests/Golden/Machine/G15.expected.txt view
@@ -0,0 +1,126 @@+pushValue (\x_0 -> \x_1 -> GHC.Show.show x_0)+  minReads=2+  mayRaise=[ExceptionFailure]+  alwaysRaise=[]+  freeRegs=[]+join join+  minReads=1+  mayRaise=[ExceptionFailure]+  alwaysRaise=[]+  freeRegs=[]+| lift2Value (\x_0 -> \x_1 -> x_0 x_1)+|   minReads=1+|   mayRaise=[ExceptionFailure]+|   alwaysRaise=[]+|   freeRegs=[]+| comment "satisfy ((GHC.Classes.==) 'c')"+|   minReads=1+|   mayRaise=[ExceptionFailure]+|   alwaysRaise=[]+|   freeRegs=[]+| read ((GHC.Classes.==) 'c')+|   minReads=1+|   mayRaise=[ExceptionFailure]+|   alwaysRaise=[]+|   freeRegs=[]+| lift2Value (\x_0 -> \x_1 -> x_0 x_1)+|   minReads=0+|   mayRaise=[]+|   alwaysRaise=[]+|   freeRegs=[]+| ret+|   minReads=0+|   mayRaise=[]+|   alwaysRaise=[]+|   freeRegs=[]+catch ExceptionFailure+  minReads=2+  mayRaise=[ExceptionFailure]+  alwaysRaise=[]+  freeRegs=[]+| <catchScope>+| | pushValue (\x_0 -> 'a')+| |   minReads=2+| |   mayRaise=[ExceptionFailure]+| |   alwaysRaise=[]+| |   freeRegs=[]+| | comment "satisfy ((GHC.Classes.==) 'a')"+| |   minReads=2+| |   mayRaise=[ExceptionFailure]+| |   alwaysRaise=[]+| |   freeRegs=[]+| | read ((GHC.Classes.==) 'a')+| |   minReads=2+| |   mayRaise=[ExceptionFailure]+| |   alwaysRaise=[]+| |   freeRegs=[]+| | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| |   minReads=1+| |   mayRaise=[ExceptionFailure]+| |   alwaysRaise=[]+| |   freeRegs=[]+| | commit ExceptionFailure+| |   minReads=1+| |   mayRaise=[ExceptionFailure]+| |   alwaysRaise=[]+| |   freeRegs=[]+| | refJoin join+| |   minReads=1+| |   mayRaise=[ExceptionFailure]+| |   alwaysRaise=[]+| |   freeRegs=[]+| <onException ExceptionFailure>+| | comment "raiseAgainIfConsumed"+| |   minReads=2+| |   mayRaise=[ExceptionFailure]+| |   alwaysRaise=[]+| |   freeRegs=[]+| | saveInput+| |   minReads=2+| |   mayRaise=[ExceptionFailure]+| |   alwaysRaise=[]+| |   freeRegs=[]+| | lift2Value (\(Data.Text.Internal.Text _ i_0 _) (Data.Text.Internal.Text _+| |                                                                j_1+| |                                                                _) -> i_0 GHC.Classes.== j_1)+| |   minReads=2+| |   mayRaise=[ExceptionFailure]+| |   alwaysRaise=[]+| |   freeRegs=[]+| | choicesBranch+| |   minReads=2+| |   mayRaise=[ExceptionFailure]+| |   alwaysRaise=[]+| |   freeRegs=[]+| | | <branch (\x_0 -> x_0)>+| | | | pushValue (\x_0 -> 'b')+| | | |   minReads=2+| | | |   mayRaise=[ExceptionFailure]+| | | |   alwaysRaise=[]+| | | |   freeRegs=[]+| | | | comment "satisfy ((GHC.Classes.==) 'b')"+| | | |   minReads=2+| | | |   mayRaise=[ExceptionFailure]+| | | |   alwaysRaise=[]+| | | |   freeRegs=[]+| | | | read ((GHC.Classes.==) 'b')+| | | |   minReads=2+| | | |   mayRaise=[ExceptionFailure]+| | | |   alwaysRaise=[]+| | | |   freeRegs=[]+| | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| | | |   minReads=1+| | | |   mayRaise=[ExceptionFailure]+| | | |   alwaysRaise=[]+| | | |   freeRegs=[]+| | | | refJoin join+| | | |   minReads=1+| | | |   mayRaise=[ExceptionFailure]+| | | |   alwaysRaise=[]+| | | |   freeRegs=[]+| | | <default>+| | | | fail []+| | | |   minReads=0+| | | |   mayRaise=[ExceptionFailure]+| | | |   alwaysRaise=[ExceptionFailure]+| | | |   freeRegs=[]
+ tests/Golden/Machine/G16.expected.txt view
@@ -0,0 +1,192 @@+pushValue (\x_0 -> \x_1 -> GHC.Show.show x_0)+  minReads=2+  mayRaise=[ExceptionFailure]+  alwaysRaise=[]+  freeRegs=[]+join join+  minReads=1+  mayRaise=[ExceptionFailure]+  alwaysRaise=[]+  freeRegs=[]+| lift2Value (\x_0 -> \x_1 -> x_0 x_1)+|   minReads=1+|   mayRaise=[ExceptionFailure]+|   alwaysRaise=[]+|   freeRegs=[]+| comment "satisfy ((GHC.Classes.==) 'd')"+|   minReads=1+|   mayRaise=[ExceptionFailure]+|   alwaysRaise=[]+|   freeRegs=[]+| read ((GHC.Classes.==) 'd')+|   minReads=1+|   mayRaise=[ExceptionFailure]+|   alwaysRaise=[]+|   freeRegs=[]+| lift2Value (\x_0 -> \x_1 -> x_0 x_1)+|   minReads=0+|   mayRaise=[]+|   alwaysRaise=[]+|   freeRegs=[]+| ret+|   minReads=0+|   mayRaise=[]+|   alwaysRaise=[]+|   freeRegs=[]+catch ExceptionFailure+  minReads=2+  mayRaise=[ExceptionFailure]+  alwaysRaise=[]+  freeRegs=[]+| <catchScope>+| | pushValue (\x_0 -> 'a')+| |   minReads=2+| |   mayRaise=[ExceptionFailure]+| |   alwaysRaise=[]+| |   freeRegs=[]+| | comment "satisfy ((GHC.Classes.==) 'a')"+| |   minReads=2+| |   mayRaise=[ExceptionFailure]+| |   alwaysRaise=[]+| |   freeRegs=[]+| | read ((GHC.Classes.==) 'a')+| |   minReads=2+| |   mayRaise=[ExceptionFailure]+| |   alwaysRaise=[]+| |   freeRegs=[]+| | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| |   minReads=1+| |   mayRaise=[ExceptionFailure]+| |   alwaysRaise=[]+| |   freeRegs=[]+| | commit ExceptionFailure+| |   minReads=1+| |   mayRaise=[ExceptionFailure]+| |   alwaysRaise=[]+| |   freeRegs=[]+| | refJoin join+| |   minReads=1+| |   mayRaise=[ExceptionFailure]+| |   alwaysRaise=[]+| |   freeRegs=[]+| <onException ExceptionFailure>+| | comment "raiseAgainIfConsumed"+| |   minReads=2+| |   mayRaise=[ExceptionFailure]+| |   alwaysRaise=[]+| |   freeRegs=[]+| | saveInput+| |   minReads=2+| |   mayRaise=[ExceptionFailure]+| |   alwaysRaise=[]+| |   freeRegs=[]+| | lift2Value (\(Data.Text.Internal.Text _ i_0 _) (Data.Text.Internal.Text _+| |                                                                j_1+| |                                                                _) -> i_0 GHC.Classes.== j_1)+| |   minReads=2+| |   mayRaise=[ExceptionFailure]+| |   alwaysRaise=[]+| |   freeRegs=[]+| | choicesBranch+| |   minReads=2+| |   mayRaise=[ExceptionFailure]+| |   alwaysRaise=[]+| |   freeRegs=[]+| | | <branch (\x_0 -> x_0)>+| | | | catch ExceptionFailure+| | | |   minReads=2+| | | |   mayRaise=[ExceptionFailure]+| | | |   alwaysRaise=[]+| | | |   freeRegs=[]+| | | | | <catchScope>+| | | | | | pushValue (\x_0 -> 'b')+| | | | | |   minReads=2+| | | | | |   mayRaise=[ExceptionFailure]+| | | | | |   alwaysRaise=[]+| | | | | |   freeRegs=[]+| | | | | | comment "satisfy ((GHC.Classes.==) 'b')"+| | | | | |   minReads=2+| | | | | |   mayRaise=[ExceptionFailure]+| | | | | |   alwaysRaise=[]+| | | | | |   freeRegs=[]+| | | | | | read ((GHC.Classes.==) 'b')+| | | | | |   minReads=2+| | | | | |   mayRaise=[ExceptionFailure]+| | | | | |   alwaysRaise=[]+| | | | | |   freeRegs=[]+| | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| | | | | |   minReads=1+| | | | | |   mayRaise=[ExceptionFailure]+| | | | | |   alwaysRaise=[]+| | | | | |   freeRegs=[]+| | | | | | commit ExceptionFailure+| | | | | |   minReads=1+| | | | | |   mayRaise=[ExceptionFailure]+| | | | | |   alwaysRaise=[]+| | | | | |   freeRegs=[]+| | | | | | refJoin join+| | | | | |   minReads=1+| | | | | |   mayRaise=[ExceptionFailure]+| | | | | |   alwaysRaise=[]+| | | | | |   freeRegs=[]+| | | | | <onException ExceptionFailure>+| | | | | | comment "raiseAgainIfConsumed"+| | | | | |   minReads=2+| | | | | |   mayRaise=[ExceptionFailure]+| | | | | |   alwaysRaise=[]+| | | | | |   freeRegs=[]+| | | | | | saveInput+| | | | | |   minReads=2+| | | | | |   mayRaise=[ExceptionFailure]+| | | | | |   alwaysRaise=[]+| | | | | |   freeRegs=[]+| | | | | | lift2Value (\(Data.Text.Internal.Text _ i_0 _) (Data.Text.Internal.Text _+| | | | | |                                                                j_1+| | | | | |                                                                _) -> i_0 GHC.Classes.== j_1)+| | | | | |   minReads=2+| | | | | |   mayRaise=[ExceptionFailure]+| | | | | |   alwaysRaise=[]+| | | | | |   freeRegs=[]+| | | | | | choicesBranch+| | | | | |   minReads=2+| | | | | |   mayRaise=[ExceptionFailure]+| | | | | |   alwaysRaise=[]+| | | | | |   freeRegs=[]+| | | | | | | <branch (\x_0 -> x_0)>+| | | | | | | | pushValue (\x_0 -> 'c')+| | | | | | | |   minReads=2+| | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | |   alwaysRaise=[]+| | | | | | | |   freeRegs=[]+| | | | | | | | comment "satisfy ((GHC.Classes.==) 'c')"+| | | | | | | |   minReads=2+| | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | |   alwaysRaise=[]+| | | | | | | |   freeRegs=[]+| | | | | | | | read ((GHC.Classes.==) 'c')+| | | | | | | |   minReads=2+| | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | |   alwaysRaise=[]+| | | | | | | |   freeRegs=[]+| | | | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| | | | | | | |   minReads=1+| | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | |   alwaysRaise=[]+| | | | | | | |   freeRegs=[]+| | | | | | | | refJoin join+| | | | | | | |   minReads=1+| | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | |   alwaysRaise=[]+| | | | | | | |   freeRegs=[]+| | | | | | | <default>+| | | | | | | | fail []+| | | | | | | |   minReads=0+| | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | |   alwaysRaise=[ExceptionFailure]+| | | | | | | |   freeRegs=[]+| | | <default>+| | | | fail []+| | | |   minReads=0+| | | |   mayRaise=[ExceptionFailure]+| | | |   alwaysRaise=[ExceptionFailure]+| | | |   freeRegs=[]
+ tests/Golden/Machine/G17.expected.txt view
@@ -0,0 +1,55 @@+pushValue GHC.Show.show+  minReads=1+  mayRaise=[ExceptionFailure]+  alwaysRaise=[]+  freeRegs=[]+comment "satisfy ((\\x_0 -> \\x_1 -> x_0) GHC.Types.True)"+  minReads=1+  mayRaise=[ExceptionFailure]+  alwaysRaise=[]+  freeRegs=[]+read (\x_0 -> GHC.Types.True)+  minReads=1+  mayRaise=[ExceptionFailure]+  alwaysRaise=[]+  freeRegs=[]+newRegister reg+  minReads=0+  mayRaise=[]+  alwaysRaise=[]+  freeRegs=[]+pushValue GHC.Tuple.(,)+  minReads=0+  mayRaise=[]+  alwaysRaise=[]+  freeRegs=[reg]+readRegister reg+  minReads=0+  mayRaise=[]+  alwaysRaise=[]+  freeRegs=[reg]+lift2Value (\x_0 -> \x_1 -> x_0 x_1)+  minReads=0+  mayRaise=[]+  alwaysRaise=[]+  freeRegs=[reg]+readRegister reg+  minReads=0+  mayRaise=[]+  alwaysRaise=[]+  freeRegs=[reg]+lift2Value (\x_0 -> \x_1 -> x_0 x_1)+  minReads=0+  mayRaise=[]+  alwaysRaise=[]+  freeRegs=[]+lift2Value (\x_0 -> \x_1 -> x_0 x_1)+  minReads=0+  mayRaise=[]+  alwaysRaise=[]+  freeRegs=[]+ret+  minReads=0+  mayRaise=[]+  alwaysRaise=[]+  freeRegs=[]
+ tests/Golden/Machine/G18.expected.txt view
@@ -0,0 +1,200 @@+pushValue GHC.Show.show+  minReads=2+  mayRaise=[ExceptionFailure]+  alwaysRaise=[]+  freeRegs=[]+join join+  minReads=0+  mayRaise=[]+  alwaysRaise=[]+  freeRegs=[]+| lift2Value (\x_0 -> \x_1 -> x_0 x_1)+|   minReads=0+|   mayRaise=[]+|   alwaysRaise=[]+|   freeRegs=[]+| ret+|   minReads=0+|   mayRaise=[]+|   alwaysRaise=[]+|   freeRegs=[]+catch ExceptionFailure+  minReads=2+  mayRaise=[ExceptionFailure]+  alwaysRaise=[]+  freeRegs=[]+| <catchScope>+| | catch ExceptionFailure+| |   minReads=3+| |   mayRaise=[ExceptionFailure]+| |   alwaysRaise=[]+| |   freeRegs=[]+| | | <catchScope>+| | | | pushValue (\x_0 -> \x_1 -> \x_2 -> (GHC.Types.:) 'a' ((GHC.Types.:) 'b' ((GHC.Types.:) 'c' GHC.Types.[])))+| | | |   minReads=3+| | | |   mayRaise=[ExceptionFailure]+| | | |   alwaysRaise=[]+| | | |   freeRegs=[]+| | | | comment "satisfy ((GHC.Classes.==) 'a')"+| | | |   minReads=3+| | | |   mayRaise=[ExceptionFailure]+| | | |   alwaysRaise=[]+| | | |   freeRegs=[]+| | | | read ((GHC.Classes.==) 'a')+| | | |   minReads=3+| | | |   mayRaise=[ExceptionFailure]+| | | |   alwaysRaise=[]+| | | |   freeRegs=[]+| | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| | | |   minReads=2+| | | |   mayRaise=[ExceptionFailure]+| | | |   alwaysRaise=[]+| | | |   freeRegs=[]+| | | | comment "satisfy ((GHC.Classes.==) 'b')"+| | | |   minReads=2+| | | |   mayRaise=[ExceptionFailure]+| | | |   alwaysRaise=[]+| | | |   freeRegs=[]+| | | | read ((GHC.Classes.==) 'b')+| | | |   minReads=2+| | | |   mayRaise=[ExceptionFailure]+| | | |   alwaysRaise=[]+| | | |   freeRegs=[]+| | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| | | |   minReads=1+| | | |   mayRaise=[ExceptionFailure]+| | | |   alwaysRaise=[]+| | | |   freeRegs=[]+| | | | comment "satisfy ((GHC.Classes.==) 'c')"+| | | |   minReads=1+| | | |   mayRaise=[ExceptionFailure]+| | | |   alwaysRaise=[]+| | | |   freeRegs=[]+| | | | read ((GHC.Classes.==) 'c')+| | | |   minReads=1+| | | |   mayRaise=[ExceptionFailure]+| | | |   alwaysRaise=[]+| | | |   freeRegs=[]+| | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| | | |   minReads=0+| | | |   mayRaise=[]+| | | |   alwaysRaise=[]+| | | |   freeRegs=[]+| | | | commit ExceptionFailure+| | | |   minReads=0+| | | |   mayRaise=[]+| | | |   alwaysRaise=[]+| | | |   freeRegs=[]+| | | | commit ExceptionFailure+| | | |   minReads=0+| | | |   mayRaise=[]+| | | |   alwaysRaise=[]+| | | |   freeRegs=[]+| | | | refJoin join+| | | |   minReads=0+| | | |   mayRaise=[]+| | | |   alwaysRaise=[]+| | | |   freeRegs=[]+| | | <onException ExceptionFailure>+| | | | loadInput+| | | |   minReads=0+| | | |   mayRaise=[ExceptionFailure]+| | | |   alwaysRaise=[ExceptionFailure]+| | | |   freeRegs=[]+| | | | fail []+| | | |   minReads=0+| | | |   mayRaise=[ExceptionFailure]+| | | |   alwaysRaise=[ExceptionFailure]+| | | |   freeRegs=[]+| <onException ExceptionFailure>+| | comment "raiseAgainIfConsumed"+| |   minReads=2+| |   mayRaise=[ExceptionFailure]+| |   alwaysRaise=[]+| |   freeRegs=[]+| | saveInput+| |   minReads=2+| |   mayRaise=[ExceptionFailure]+| |   alwaysRaise=[]+| |   freeRegs=[]+| | lift2Value (\(Data.Text.Internal.Text _ i_0 _) (Data.Text.Internal.Text _+| |                                                                j_1+| |                                                                _) -> i_0 GHC.Classes.== j_1)+| |   minReads=2+| |   mayRaise=[ExceptionFailure]+| |   alwaysRaise=[]+| |   freeRegs=[]+| | choicesBranch+| |   minReads=2+| |   mayRaise=[ExceptionFailure]+| |   alwaysRaise=[]+| |   freeRegs=[]+| | | <branch (\x_0 -> x_0)>+| | | | catch ExceptionFailure+| | | |   minReads=2+| | | |   mayRaise=[ExceptionFailure]+| | | |   alwaysRaise=[]+| | | |   freeRegs=[]+| | | | | <catchScope>+| | | | | | pushValue (\x_0 -> \x_1 -> (GHC.Types.:) 'd' ((GHC.Types.:) 'e' GHC.Types.[]))+| | | | | |   minReads=2+| | | | | |   mayRaise=[ExceptionFailure]+| | | | | |   alwaysRaise=[]+| | | | | |   freeRegs=[]+| | | | | | comment "satisfy ((GHC.Classes.==) 'd')"+| | | | | |   minReads=2+| | | | | |   mayRaise=[ExceptionFailure]+| | | | | |   alwaysRaise=[]+| | | | | |   freeRegs=[]+| | | | | | read ((GHC.Classes.==) 'd')+| | | | | |   minReads=2+| | | | | |   mayRaise=[ExceptionFailure]+| | | | | |   alwaysRaise=[]+| | | | | |   freeRegs=[]+| | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| | | | | |   minReads=1+| | | | | |   mayRaise=[ExceptionFailure]+| | | | | |   alwaysRaise=[]+| | | | | |   freeRegs=[]+| | | | | | comment "satisfy ((GHC.Classes.==) 'e')"+| | | | | |   minReads=1+| | | | | |   mayRaise=[ExceptionFailure]+| | | | | |   alwaysRaise=[]+| | | | | |   freeRegs=[]+| | | | | | read ((GHC.Classes.==) 'e')+| | | | | |   minReads=1+| | | | | |   mayRaise=[ExceptionFailure]+| | | | | |   alwaysRaise=[]+| | | | | |   freeRegs=[]+| | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| | | | | |   minReads=0+| | | | | |   mayRaise=[]+| | | | | |   alwaysRaise=[]+| | | | | |   freeRegs=[]+| | | | | | commit ExceptionFailure+| | | | | |   minReads=0+| | | | | |   mayRaise=[]+| | | | | |   alwaysRaise=[]+| | | | | |   freeRegs=[]+| | | | | | refJoin join+| | | | | |   minReads=0+| | | | | |   mayRaise=[]+| | | | | |   alwaysRaise=[]+| | | | | |   freeRegs=[]+| | | | | <onException ExceptionFailure>+| | | | | | loadInput+| | | | | |   minReads=0+| | | | | |   mayRaise=[ExceptionFailure]+| | | | | |   alwaysRaise=[ExceptionFailure]+| | | | | |   freeRegs=[]+| | | | | | fail []+| | | | | |   minReads=0+| | | | | |   mayRaise=[ExceptionFailure]+| | | | | |   alwaysRaise=[ExceptionFailure]+| | | | | |   freeRegs=[]+| | | <default>+| | | | fail []+| | | |   minReads=0+| | | |   mayRaise=[ExceptionFailure]+| | | |   alwaysRaise=[ExceptionFailure]+| | | |   freeRegs=[]
+ tests/Golden/Machine/G19.expected.txt view
@@ -0,0 +1,333 @@+pushValue GHC.Show.show+  minReads=2+  mayRaise=[ExceptionFailure]+  alwaysRaise=[]+  freeRegs=[]+join join+  minReads=0+  mayRaise=[]+  alwaysRaise=[]+  freeRegs=[]+| lift2Value (\x_0 -> \x_1 -> x_0 x_1)+|   minReads=0+|   mayRaise=[]+|   alwaysRaise=[]+|   freeRegs=[]+| ret+|   minReads=0+|   mayRaise=[]+|   alwaysRaise=[]+|   freeRegs=[]+catch ExceptionFailure+  minReads=2+  mayRaise=[ExceptionFailure]+  alwaysRaise=[]+  freeRegs=[]+| <catchScope>+| | catch ExceptionFailure+| |   minReads=3+| |   mayRaise=[ExceptionFailure]+| |   alwaysRaise=[]+| |   freeRegs=[]+| | | <catchScope>+| | | | pushValue (\x_0 -> \x_1 -> \x_2 -> (GHC.Types.:) 'a' ((GHC.Types.:) 'b' ((GHC.Types.:) 'c' GHC.Types.[])))+| | | |   minReads=3+| | | |   mayRaise=[ExceptionFailure]+| | | |   alwaysRaise=[]+| | | |   freeRegs=[]+| | | | comment "satisfy ((GHC.Classes.==) 'a')"+| | | |   minReads=3+| | | |   mayRaise=[ExceptionFailure]+| | | |   alwaysRaise=[]+| | | |   freeRegs=[]+| | | | read ((GHC.Classes.==) 'a')+| | | |   minReads=3+| | | |   mayRaise=[ExceptionFailure]+| | | |   alwaysRaise=[]+| | | |   freeRegs=[]+| | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| | | |   minReads=2+| | | |   mayRaise=[ExceptionFailure]+| | | |   alwaysRaise=[]+| | | |   freeRegs=[]+| | | | comment "satisfy ((GHC.Classes.==) 'b')"+| | | |   minReads=2+| | | |   mayRaise=[ExceptionFailure]+| | | |   alwaysRaise=[]+| | | |   freeRegs=[]+| | | | read ((GHC.Classes.==) 'b')+| | | |   minReads=2+| | | |   mayRaise=[ExceptionFailure]+| | | |   alwaysRaise=[]+| | | |   freeRegs=[]+| | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| | | |   minReads=1+| | | |   mayRaise=[ExceptionFailure]+| | | |   alwaysRaise=[]+| | | |   freeRegs=[]+| | | | comment "satisfy ((GHC.Classes.==) 'c')"+| | | |   minReads=1+| | | |   mayRaise=[ExceptionFailure]+| | | |   alwaysRaise=[]+| | | |   freeRegs=[]+| | | | read ((GHC.Classes.==) 'c')+| | | |   minReads=1+| | | |   mayRaise=[ExceptionFailure]+| | | |   alwaysRaise=[]+| | | |   freeRegs=[]+| | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| | | |   minReads=0+| | | |   mayRaise=[]+| | | |   alwaysRaise=[]+| | | |   freeRegs=[]+| | | | commit ExceptionFailure+| | | |   minReads=0+| | | |   mayRaise=[]+| | | |   alwaysRaise=[]+| | | |   freeRegs=[]+| | | | commit ExceptionFailure+| | | |   minReads=0+| | | |   mayRaise=[]+| | | |   alwaysRaise=[]+| | | |   freeRegs=[]+| | | | refJoin join+| | | |   minReads=0+| | | |   mayRaise=[]+| | | |   alwaysRaise=[]+| | | |   freeRegs=[]+| | | <onException ExceptionFailure>+| | | | loadInput+| | | |   minReads=0+| | | |   mayRaise=[ExceptionFailure]+| | | |   alwaysRaise=[ExceptionFailure]+| | | |   freeRegs=[]+| | | | fail []+| | | |   minReads=0+| | | |   mayRaise=[ExceptionFailure]+| | | |   alwaysRaise=[ExceptionFailure]+| | | |   freeRegs=[]+| <onException ExceptionFailure>+| | comment "raiseAgainIfConsumed"+| |   minReads=2+| |   mayRaise=[ExceptionFailure]+| |   alwaysRaise=[]+| |   freeRegs=[]+| | saveInput+| |   minReads=2+| |   mayRaise=[ExceptionFailure]+| |   alwaysRaise=[]+| |   freeRegs=[]+| | lift2Value (\(Data.Text.Internal.Text _ i_0 _) (Data.Text.Internal.Text _+| |                                                                j_1+| |                                                                _) -> i_0 GHC.Classes.== j_1)+| |   minReads=2+| |   mayRaise=[ExceptionFailure]+| |   alwaysRaise=[]+| |   freeRegs=[]+| | choicesBranch+| |   minReads=2+| |   mayRaise=[ExceptionFailure]+| |   alwaysRaise=[]+| |   freeRegs=[]+| | | <branch (\x_0 -> x_0)>+| | | | catch ExceptionFailure+| | | |   minReads=2+| | | |   mayRaise=[ExceptionFailure]+| | | |   alwaysRaise=[]+| | | |   freeRegs=[]+| | | | | <catchScope>+| | | | | | catch ExceptionFailure+| | | | | |   minReads=2+| | | | | |   mayRaise=[ExceptionFailure]+| | | | | |   alwaysRaise=[]+| | | | | |   freeRegs=[]+| | | | | | | <catchScope>+| | | | | | | | pushValue (\x_0 -> \x_1 -> (GHC.Types.:) 'd' ((GHC.Types.:) 'e' GHC.Types.[]))+| | | | | | | |   minReads=2+| | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | |   alwaysRaise=[]+| | | | | | | |   freeRegs=[]+| | | | | | | | comment "satisfy ((GHC.Classes.==) 'd')"+| | | | | | | |   minReads=2+| | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | |   alwaysRaise=[]+| | | | | | | |   freeRegs=[]+| | | | | | | | read ((GHC.Classes.==) 'd')+| | | | | | | |   minReads=2+| | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | |   alwaysRaise=[]+| | | | | | | |   freeRegs=[]+| | | | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| | | | | | | |   minReads=1+| | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | |   alwaysRaise=[]+| | | | | | | |   freeRegs=[]+| | | | | | | | comment "satisfy ((GHC.Classes.==) 'e')"+| | | | | | | |   minReads=1+| | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | |   alwaysRaise=[]+| | | | | | | |   freeRegs=[]+| | | | | | | | read ((GHC.Classes.==) 'e')+| | | | | | | |   minReads=1+| | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | |   alwaysRaise=[]+| | | | | | | |   freeRegs=[]+| | | | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| | | | | | | |   minReads=0+| | | | | | | |   mayRaise=[]+| | | | | | | |   alwaysRaise=[]+| | | | | | | |   freeRegs=[]+| | | | | | | | commit ExceptionFailure+| | | | | | | |   minReads=0+| | | | | | | |   mayRaise=[]+| | | | | | | |   alwaysRaise=[]+| | | | | | | |   freeRegs=[]+| | | | | | | | commit ExceptionFailure+| | | | | | | |   minReads=0+| | | | | | | |   mayRaise=[]+| | | | | | | |   alwaysRaise=[]+| | | | | | | |   freeRegs=[]+| | | | | | | | refJoin join+| | | | | | | |   minReads=0+| | | | | | | |   mayRaise=[]+| | | | | | | |   alwaysRaise=[]+| | | | | | | |   freeRegs=[]+| | | | | | | <onException ExceptionFailure>+| | | | | | | | loadInput+| | | | | | | |   minReads=0+| | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | |   alwaysRaise=[ExceptionFailure]+| | | | | | | |   freeRegs=[]+| | | | | | | | fail []+| | | | | | | |   minReads=0+| | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | |   alwaysRaise=[ExceptionFailure]+| | | | | | | |   freeRegs=[]+| | | | | <onException ExceptionFailure>+| | | | | | comment "raiseAgainIfConsumed"+| | | | | |   minReads=4+| | | | | |   mayRaise=[ExceptionFailure]+| | | | | |   alwaysRaise=[]+| | | | | |   freeRegs=[]+| | | | | | saveInput+| | | | | |   minReads=4+| | | | | |   mayRaise=[ExceptionFailure]+| | | | | |   alwaysRaise=[]+| | | | | |   freeRegs=[]+| | | | | | lift2Value (\(Data.Text.Internal.Text _ i_0 _) (Data.Text.Internal.Text _+| | | | | |                                                                j_1+| | | | | |                                                                _) -> i_0 GHC.Classes.== j_1)+| | | | | |   minReads=4+| | | | | |   mayRaise=[ExceptionFailure]+| | | | | |   alwaysRaise=[]+| | | | | |   freeRegs=[]+| | | | | | choicesBranch+| | | | | |   minReads=4+| | | | | |   mayRaise=[ExceptionFailure]+| | | | | |   alwaysRaise=[]+| | | | | |   freeRegs=[]+| | | | | | | <branch (\x_0 -> x_0)>+| | | | | | | | catch ExceptionFailure+| | | | | | | |   minReads=4+| | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | |   alwaysRaise=[]+| | | | | | | |   freeRegs=[]+| | | | | | | | | <catchScope>+| | | | | | | | | | pushValue (\x_0 -> \x_1 -> \x_2 -> \x_3 -> (GHC.Types.:) 'f' ((GHC.Types.:) 'g' ((GHC.Types.:) 'h' ((GHC.Types.:) 'i' GHC.Types.[]))))+| | | | | | | | | |   minReads=4+| | | | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | | | |   alwaysRaise=[]+| | | | | | | | | |   freeRegs=[]+| | | | | | | | | | comment "satisfy ((GHC.Classes.==) 'f')"+| | | | | | | | | |   minReads=4+| | | | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | | | |   alwaysRaise=[]+| | | | | | | | | |   freeRegs=[]+| | | | | | | | | | read ((GHC.Classes.==) 'f')+| | | | | | | | | |   minReads=4+| | | | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | | | |   alwaysRaise=[]+| | | | | | | | | |   freeRegs=[]+| | | | | | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| | | | | | | | | |   minReads=3+| | | | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | | | |   alwaysRaise=[]+| | | | | | | | | |   freeRegs=[]+| | | | | | | | | | comment "satisfy ((GHC.Classes.==) 'g')"+| | | | | | | | | |   minReads=3+| | | | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | | | |   alwaysRaise=[]+| | | | | | | | | |   freeRegs=[]+| | | | | | | | | | read ((GHC.Classes.==) 'g')+| | | | | | | | | |   minReads=3+| | | | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | | | |   alwaysRaise=[]+| | | | | | | | | |   freeRegs=[]+| | | | | | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| | | | | | | | | |   minReads=2+| | | | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | | | |   alwaysRaise=[]+| | | | | | | | | |   freeRegs=[]+| | | | | | | | | | comment "satisfy ((GHC.Classes.==) 'h')"+| | | | | | | | | |   minReads=2+| | | | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | | | |   alwaysRaise=[]+| | | | | | | | | |   freeRegs=[]+| | | | | | | | | | read ((GHC.Classes.==) 'h')+| | | | | | | | | |   minReads=2+| | | | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | | | |   alwaysRaise=[]+| | | | | | | | | |   freeRegs=[]+| | | | | | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| | | | | | | | | |   minReads=1+| | | | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | | | |   alwaysRaise=[]+| | | | | | | | | |   freeRegs=[]+| | | | | | | | | | comment "satisfy ((GHC.Classes.==) 'i')"+| | | | | | | | | |   minReads=1+| | | | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | | | |   alwaysRaise=[]+| | | | | | | | | |   freeRegs=[]+| | | | | | | | | | read ((GHC.Classes.==) 'i')+| | | | | | | | | |   minReads=1+| | | | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | | | |   alwaysRaise=[]+| | | | | | | | | |   freeRegs=[]+| | | | | | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| | | | | | | | | |   minReads=0+| | | | | | | | | |   mayRaise=[]+| | | | | | | | | |   alwaysRaise=[]+| | | | | | | | | |   freeRegs=[]+| | | | | | | | | | commit ExceptionFailure+| | | | | | | | | |   minReads=0+| | | | | | | | | |   mayRaise=[]+| | | | | | | | | |   alwaysRaise=[]+| | | | | | | | | |   freeRegs=[]+| | | | | | | | | | refJoin join+| | | | | | | | | |   minReads=0+| | | | | | | | | |   mayRaise=[]+| | | | | | | | | |   alwaysRaise=[]+| | | | | | | | | |   freeRegs=[]+| | | | | | | | | <onException ExceptionFailure>+| | | | | | | | | | loadInput+| | | | | | | | | |   minReads=0+| | | | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | | | |   alwaysRaise=[ExceptionFailure]+| | | | | | | | | |   freeRegs=[]+| | | | | | | | | | fail []+| | | | | | | | | |   minReads=0+| | | | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | | | |   alwaysRaise=[ExceptionFailure]+| | | | | | | | | |   freeRegs=[]+| | | | | | | <default>+| | | | | | | | fail []+| | | | | | | |   minReads=0+| | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | |   alwaysRaise=[ExceptionFailure]+| | | | | | | |   freeRegs=[]+| | | <default>+| | | | fail []+| | | |   minReads=0+| | | |   mayRaise=[ExceptionFailure]+| | | |   alwaysRaise=[ExceptionFailure]+| | | |   freeRegs=[]
+ tests/Golden/Machine/G2.expected.txt view
@@ -0,0 +1,87 @@+pushValue GHC.Show.show+  minReads=3+  mayRaise=[ExceptionFailure]+  alwaysRaise=[]+  freeRegs=[]+catch ExceptionFailure+  minReads=3+  mayRaise=[ExceptionFailure]+  alwaysRaise=[]+  freeRegs=[]+| <catchScope>+| | pushValue (\x_0 -> \x_1 -> \x_2 -> (GHC.Types.:) 'a' ((GHC.Types.:) 'b' ((GHC.Types.:) 'c' GHC.Types.[])))+| |   minReads=3+| |   mayRaise=[ExceptionFailure]+| |   alwaysRaise=[]+| |   freeRegs=[]+| | comment "satisfy ((GHC.Classes.==) 'a')"+| |   minReads=3+| |   mayRaise=[ExceptionFailure]+| |   alwaysRaise=[]+| |   freeRegs=[]+| | read ((GHC.Classes.==) 'a')+| |   minReads=3+| |   mayRaise=[ExceptionFailure]+| |   alwaysRaise=[]+| |   freeRegs=[]+| | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| |   minReads=2+| |   mayRaise=[ExceptionFailure]+| |   alwaysRaise=[]+| |   freeRegs=[]+| | comment "satisfy ((GHC.Classes.==) 'b')"+| |   minReads=2+| |   mayRaise=[ExceptionFailure]+| |   alwaysRaise=[]+| |   freeRegs=[]+| | read ((GHC.Classes.==) 'b')+| |   minReads=2+| |   mayRaise=[ExceptionFailure]+| |   alwaysRaise=[]+| |   freeRegs=[]+| | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| |   minReads=1+| |   mayRaise=[ExceptionFailure]+| |   alwaysRaise=[]+| |   freeRegs=[]+| | comment "satisfy ((GHC.Classes.==) 'c')"+| |   minReads=1+| |   mayRaise=[ExceptionFailure]+| |   alwaysRaise=[]+| |   freeRegs=[]+| | read ((GHC.Classes.==) 'c')+| |   minReads=1+| |   mayRaise=[ExceptionFailure]+| |   alwaysRaise=[]+| |   freeRegs=[]+| | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| |   minReads=0+| |   mayRaise=[]+| |   alwaysRaise=[]+| |   freeRegs=[]+| | commit ExceptionFailure+| |   minReads=0+| |   mayRaise=[]+| |   alwaysRaise=[]+| |   freeRegs=[]+| | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| |   minReads=0+| |   mayRaise=[]+| |   alwaysRaise=[]+| |   freeRegs=[]+| | ret+| |   minReads=0+| |   mayRaise=[]+| |   alwaysRaise=[]+| |   freeRegs=[]+| <onException ExceptionFailure>+| | loadInput+| |   minReads=0+| |   mayRaise=[ExceptionFailure]+| |   alwaysRaise=[ExceptionFailure]+| |   freeRegs=[]+| | fail []+| |   minReads=0+| |   mayRaise=[ExceptionFailure]+| |   alwaysRaise=[ExceptionFailure]+| |   freeRegs=[]
+ tests/Golden/Machine/G20.expected.txt view
@@ -0,0 +1,247 @@+pushValue (\x_0 -> \x_1 -> GHC.Show.show GHC.Tuple.())+  minReads=3+  mayRaise=[ExceptionFailure]+  alwaysRaise=[]+  freeRegs=[]+join join+  minReads=3+  mayRaise=[ExceptionFailure]+  alwaysRaise=[]+  freeRegs=[]+| lift2Value (\x_0 -> \x_1 -> x_0 x_1)+|   minReads=3+|   mayRaise=[ExceptionFailure]+|   alwaysRaise=[]+|   freeRegs=[]+| catch ExceptionFailure+|   minReads=3+|   mayRaise=[ExceptionFailure]+|   alwaysRaise=[]+|   freeRegs=[]+| | <catchScope>+| | | pushValue (\x_0 -> \x_1 -> \x_2 -> (GHC.Types.:) 'd' ((GHC.Types.:) 'e' ((GHC.Types.:) 'f' GHC.Types.[])))+| | |   minReads=3+| | |   mayRaise=[ExceptionFailure]+| | |   alwaysRaise=[]+| | |   freeRegs=[]+| | | comment "satisfy ((GHC.Classes.==) 'd')"+| | |   minReads=3+| | |   mayRaise=[ExceptionFailure]+| | |   alwaysRaise=[]+| | |   freeRegs=[]+| | | read ((GHC.Classes.==) 'd')+| | |   minReads=3+| | |   mayRaise=[ExceptionFailure]+| | |   alwaysRaise=[]+| | |   freeRegs=[]+| | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| | |   minReads=2+| | |   mayRaise=[ExceptionFailure]+| | |   alwaysRaise=[]+| | |   freeRegs=[]+| | | comment "satisfy ((GHC.Classes.==) 'e')"+| | |   minReads=2+| | |   mayRaise=[ExceptionFailure]+| | |   alwaysRaise=[]+| | |   freeRegs=[]+| | | read ((GHC.Classes.==) 'e')+| | |   minReads=2+| | |   mayRaise=[ExceptionFailure]+| | |   alwaysRaise=[]+| | |   freeRegs=[]+| | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| | |   minReads=1+| | |   mayRaise=[ExceptionFailure]+| | |   alwaysRaise=[]+| | |   freeRegs=[]+| | | comment "satisfy ((GHC.Classes.==) 'f')"+| | |   minReads=1+| | |   mayRaise=[ExceptionFailure]+| | |   alwaysRaise=[]+| | |   freeRegs=[]+| | | read ((GHC.Classes.==) 'f')+| | |   minReads=1+| | |   mayRaise=[ExceptionFailure]+| | |   alwaysRaise=[]+| | |   freeRegs=[]+| | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| | |   minReads=0+| | |   mayRaise=[]+| | |   alwaysRaise=[]+| | |   freeRegs=[]+| | | commit ExceptionFailure+| | |   minReads=0+| | |   mayRaise=[]+| | |   alwaysRaise=[]+| | |   freeRegs=[]+| | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| | |   minReads=0+| | |   mayRaise=[]+| | |   alwaysRaise=[]+| | |   freeRegs=[]+| | | ret+| | |   minReads=0+| | |   mayRaise=[]+| | |   alwaysRaise=[]+| | |   freeRegs=[]+| | <onException ExceptionFailure>+| | | loadInput+| | |   minReads=0+| | |   mayRaise=[ExceptionFailure]+| | |   alwaysRaise=[ExceptionFailure]+| | |   freeRegs=[]+| | | fail []+| | |   minReads=0+| | |   mayRaise=[ExceptionFailure]+| | |   alwaysRaise=[ExceptionFailure]+| | |   freeRegs=[]+catch ExceptionFailure+  minReads=3+  mayRaise=[ExceptionFailure]+  alwaysRaise=[]+  freeRegs=[]+| <catchScope>+| | catch ExceptionFailure+| |   minReads=6+| |   mayRaise=[ExceptionFailure]+| |   alwaysRaise=[]+| |   freeRegs=[]+| | | <catchScope>+| | | | pushValue (\x_0 -> \x_1 -> \x_2 -> (GHC.Types.:) 'a' ((GHC.Types.:) 'b' ((GHC.Types.:) 'c' GHC.Types.[])))+| | | |   minReads=6+| | | |   mayRaise=[ExceptionFailure]+| | | |   alwaysRaise=[]+| | | |   freeRegs=[]+| | | | comment "satisfy ((GHC.Classes.==) 'a')"+| | | |   minReads=6+| | | |   mayRaise=[ExceptionFailure]+| | | |   alwaysRaise=[]+| | | |   freeRegs=[]+| | | | read ((GHC.Classes.==) 'a')+| | | |   minReads=6+| | | |   mayRaise=[ExceptionFailure]+| | | |   alwaysRaise=[]+| | | |   freeRegs=[]+| | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| | | |   minReads=5+| | | |   mayRaise=[ExceptionFailure]+| | | |   alwaysRaise=[]+| | | |   freeRegs=[]+| | | | comment "satisfy ((GHC.Classes.==) 'b')"+| | | |   minReads=5+| | | |   mayRaise=[ExceptionFailure]+| | | |   alwaysRaise=[]+| | | |   freeRegs=[]+| | | | read ((GHC.Classes.==) 'b')+| | | |   minReads=5+| | | |   mayRaise=[ExceptionFailure]+| | | |   alwaysRaise=[]+| | | |   freeRegs=[]+| | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| | | |   minReads=4+| | | |   mayRaise=[ExceptionFailure]+| | | |   alwaysRaise=[]+| | | |   freeRegs=[]+| | | | comment "satisfy ((GHC.Classes.==) 'c')"+| | | |   minReads=4+| | | |   mayRaise=[ExceptionFailure]+| | | |   alwaysRaise=[]+| | | |   freeRegs=[]+| | | | read ((GHC.Classes.==) 'c')+| | | |   minReads=4+| | | |   mayRaise=[ExceptionFailure]+| | | |   alwaysRaise=[]+| | | |   freeRegs=[]+| | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| | | |   minReads=3+| | | |   mayRaise=[ExceptionFailure]+| | | |   alwaysRaise=[]+| | | |   freeRegs=[]+| | | | commit ExceptionFailure+| | | |   minReads=3+| | | |   mayRaise=[ExceptionFailure]+| | | |   alwaysRaise=[]+| | | |   freeRegs=[]+| | | | commit ExceptionFailure+| | | |   minReads=3+| | | |   mayRaise=[ExceptionFailure]+| | | |   alwaysRaise=[]+| | | |   freeRegs=[]+| | | | refJoin join+| | | |   minReads=3+| | | |   mayRaise=[ExceptionFailure]+| | | |   alwaysRaise=[]+| | | |   freeRegs=[]+| | | <onException ExceptionFailure>+| | | | loadInput+| | | |   minReads=0+| | | |   mayRaise=[ExceptionFailure]+| | | |   alwaysRaise=[ExceptionFailure]+| | | |   freeRegs=[]+| | | | fail []+| | | |   minReads=0+| | | |   mayRaise=[ExceptionFailure]+| | | |   alwaysRaise=[ExceptionFailure]+| | | |   freeRegs=[]+| <onException ExceptionFailure>+| | comment "raiseAgainIfConsumed"+| |   minReads=3+| |   mayRaise=[ExceptionFailure]+| |   alwaysRaise=[]+| |   freeRegs=[]+| | saveInput+| |   minReads=3+| |   mayRaise=[ExceptionFailure]+| |   alwaysRaise=[]+| |   freeRegs=[]+| | lift2Value (\(Data.Text.Internal.Text _ i_0 _) (Data.Text.Internal.Text _+| |                                                                j_1+| |                                                                _) -> i_0 GHC.Classes.== j_1)+| |   minReads=3+| |   mayRaise=[ExceptionFailure]+| |   alwaysRaise=[]+| |   freeRegs=[]+| | choicesBranch+| |   minReads=3+| |   mayRaise=[ExceptionFailure]+| |   alwaysRaise=[]+| |   freeRegs=[]+| | | <branch (\x_0 -> x_0)>+| | | | catch ExceptionFailure+| | | |   minReads=3+| | | |   mayRaise=[ExceptionFailure]+| | | |   alwaysRaise=[]+| | | |   freeRegs=[]+| | | | | <catchScope>+| | | | | | pushValue GHC.Types.[]+| | | | | |   minReads=3+| | | | | |   mayRaise=[ExceptionFailure]+| | | | | |   alwaysRaise=[]+| | | | | |   freeRegs=[]+| | | | | | commit ExceptionFailure+| | | | | |   minReads=3+| | | | | |   mayRaise=[ExceptionFailure]+| | | | | |   alwaysRaise=[]+| | | | | |   freeRegs=[]+| | | | | | refJoin join+| | | | | |   minReads=3+| | | | | |   mayRaise=[ExceptionFailure]+| | | | | |   alwaysRaise=[]+| | | | | |   freeRegs=[]+| | | | | <onException ExceptionFailure>+| | | | | | loadInput+| | | | | |   minReads=0+| | | | | |   mayRaise=[ExceptionFailure]+| | | | | |   alwaysRaise=[ExceptionFailure]+| | | | | |   freeRegs=[]+| | | | | | fail []+| | | | | |   minReads=0+| | | | | |   mayRaise=[ExceptionFailure]+| | | | | |   alwaysRaise=[ExceptionFailure]+| | | | | |   freeRegs=[]+| | | <default>+| | | | fail []+| | | |   minReads=0+| | | |   mayRaise=[ExceptionFailure]+| | | |   alwaysRaise=[ExceptionFailure]+| | | |   freeRegs=[]
+ tests/Golden/Machine/G3.expected.txt view
@@ -0,0 +1,126 @@+pushValue GHC.Show.show+  minReads=0+  mayRaise=[ExceptionFailure]+  alwaysRaise=[]+  freeRegs=[]+pushValue (\x_0 -> x_0)+  minReads=0+  mayRaise=[ExceptionFailure]+  alwaysRaise=[]+  freeRegs=[]+newRegister reg+  minReads=0+  mayRaise=[ExceptionFailure]+  alwaysRaise=[]+  freeRegs=[]+iter loop+  minReads=0+  mayRaise=[ExceptionFailure]+  alwaysRaise=[]+  freeRegs=[reg]+| <ok>+| | pushValue (\x_0 -> (GHC.Types.:) 'a')+| |   minReads=1+| |   mayRaise=[ExceptionFailure]+| |   alwaysRaise=[]+| |   freeRegs=[reg]+| | comment "satisfy ((GHC.Classes.==) 'a')"+| |   minReads=1+| |   mayRaise=[ExceptionFailure]+| |   alwaysRaise=[]+| |   freeRegs=[reg]+| | read ((GHC.Classes.==) 'a')+| |   minReads=1+| |   mayRaise=[ExceptionFailure]+| |   alwaysRaise=[]+| |   freeRegs=[reg]+| | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| |   minReads=0+| |   mayRaise=[]+| |   alwaysRaise=[]+| |   freeRegs=[reg]+| | pushValue (\x_0 -> \x_1 -> \x_2 -> x_1 (x_0 x_2))+| |   minReads=0+| |   mayRaise=[]+| |   alwaysRaise=[]+| |   freeRegs=[reg]+| | lift2Value (\x_0 -> \x_1 -> x_1 x_0)+| |   minReads=0+| |   mayRaise=[]+| |   alwaysRaise=[]+| |   freeRegs=[reg]+| | readRegister reg+| |   minReads=0+| |   mayRaise=[]+| |   alwaysRaise=[]+| |   freeRegs=[reg]+| | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| |   minReads=0+| |   mayRaise=[]+| |   alwaysRaise=[]+| |   freeRegs=[reg]+| | writeRegister reg+| |   minReads=0+| |   mayRaise=[]+| |   alwaysRaise=[]+| |   freeRegs=[reg]+| | jump loop+| |   minReads=0+| |   mayRaise=[]+| |   alwaysRaise=[]+| |   freeRegs=[]+| <ko>+| | comment "raiseAgainIfConsumed"+| |   minReads=0+| |   mayRaise=[ExceptionFailure]+| |   alwaysRaise=[]+| |   freeRegs=[reg]+| | saveInput+| |   minReads=0+| |   mayRaise=[ExceptionFailure]+| |   alwaysRaise=[]+| |   freeRegs=[reg]+| | lift2Value (\(Data.Text.Internal.Text _ i_0 _) (Data.Text.Internal.Text _+| |                                                                j_1+| |                                                                _) -> i_0 GHC.Classes.== j_1)+| |   minReads=0+| |   mayRaise=[ExceptionFailure]+| |   alwaysRaise=[]+| |   freeRegs=[reg]+| | choicesBranch+| |   minReads=0+| |   mayRaise=[ExceptionFailure]+| |   alwaysRaise=[]+| |   freeRegs=[reg]+| | | <branch (\x_0 -> x_0)>+| | | | readRegister reg+| | | |   minReads=0+| | | |   mayRaise=[]+| | | |   alwaysRaise=[]+| | | |   freeRegs=[reg]+| | | | pushValue GHC.Types.[]+| | | |   minReads=0+| | | |   mayRaise=[]+| | | |   alwaysRaise=[]+| | | |   freeRegs=[]+| | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| | | |   minReads=0+| | | |   mayRaise=[]+| | | |   alwaysRaise=[]+| | | |   freeRegs=[]+| | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| | | |   minReads=0+| | | |   mayRaise=[]+| | | |   alwaysRaise=[]+| | | |   freeRegs=[]+| | | | ret+| | | |   minReads=0+| | | |   mayRaise=[]+| | | |   alwaysRaise=[]+| | | |   freeRegs=[]+| | | <default>+| | | | fail []+| | | |   minReads=0+| | | |   mayRaise=[ExceptionFailure]+| | | |   alwaysRaise=[ExceptionFailure]+| | | |   freeRegs=[]
+ tests/Golden/Machine/G4.expected.txt view
@@ -0,0 +1,228 @@+let name+  minReads=4+  mayRaise=[ExceptionFailure]+  alwaysRaise=[]+  freeRegs=[]+| catch ExceptionFailure+|   minReads=4+|   mayRaise=[ExceptionFailure]+|   alwaysRaise=[]+|   freeRegs=[]+| | <catchScope>+| | | pushValue (\x_0 -> \x_1 -> \x_2 -> \x_3 -> (GHC.Types.:) 'a' ((GHC.Types.:) 'b' ((GHC.Types.:) 'c' ((GHC.Types.:) 'd' GHC.Types.[]))))+| | |   minReads=4+| | |   mayRaise=[ExceptionFailure]+| | |   alwaysRaise=[]+| | |   freeRegs=[]+| | | comment "satisfy ((GHC.Classes.==) 'a')"+| | |   minReads=4+| | |   mayRaise=[ExceptionFailure]+| | |   alwaysRaise=[]+| | |   freeRegs=[]+| | | read ((GHC.Classes.==) 'a')+| | |   minReads=4+| | |   mayRaise=[ExceptionFailure]+| | |   alwaysRaise=[]+| | |   freeRegs=[]+| | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| | |   minReads=3+| | |   mayRaise=[ExceptionFailure]+| | |   alwaysRaise=[]+| | |   freeRegs=[]+| | | comment "satisfy ((GHC.Classes.==) 'b')"+| | |   minReads=3+| | |   mayRaise=[ExceptionFailure]+| | |   alwaysRaise=[]+| | |   freeRegs=[]+| | | read ((GHC.Classes.==) 'b')+| | |   minReads=3+| | |   mayRaise=[ExceptionFailure]+| | |   alwaysRaise=[]+| | |   freeRegs=[]+| | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| | |   minReads=2+| | |   mayRaise=[ExceptionFailure]+| | |   alwaysRaise=[]+| | |   freeRegs=[]+| | | comment "satisfy ((GHC.Classes.==) 'c')"+| | |   minReads=2+| | |   mayRaise=[ExceptionFailure]+| | |   alwaysRaise=[]+| | |   freeRegs=[]+| | | read ((GHC.Classes.==) 'c')+| | |   minReads=2+| | |   mayRaise=[ExceptionFailure]+| | |   alwaysRaise=[]+| | |   freeRegs=[]+| | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| | |   minReads=1+| | |   mayRaise=[ExceptionFailure]+| | |   alwaysRaise=[]+| | |   freeRegs=[]+| | | comment "satisfy ((GHC.Classes.==) 'd')"+| | |   minReads=1+| | |   mayRaise=[ExceptionFailure]+| | |   alwaysRaise=[]+| | |   freeRegs=[]+| | | read ((GHC.Classes.==) 'd')+| | |   minReads=1+| | |   mayRaise=[ExceptionFailure]+| | |   alwaysRaise=[]+| | |   freeRegs=[]+| | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| | |   minReads=0+| | |   mayRaise=[]+| | |   alwaysRaise=[]+| | |   freeRegs=[]+| | | commit ExceptionFailure+| | |   minReads=0+| | |   mayRaise=[]+| | |   alwaysRaise=[]+| | |   freeRegs=[]+| | | ret+| | |   minReads=0+| | |   mayRaise=[]+| | |   alwaysRaise=[]+| | |   freeRegs=[]+| | <onException ExceptionFailure>+| | | loadInput+| | |   minReads=0+| | |   mayRaise=[ExceptionFailure]+| | |   alwaysRaise=[ExceptionFailure]+| | |   freeRegs=[]+| | | fail []+| | |   minReads=0+| | |   mayRaise=[ExceptionFailure]+| | |   alwaysRaise=[ExceptionFailure]+| | |   freeRegs=[]+pushValue (\x_0 -> \x_1 -> GHC.Show.show ((GHC.Types.:) x_0 x_1))+  minReads=4+  mayRaise=[ExceptionFailure]+  alwaysRaise=[]+  freeRegs=[]+call name+  minReads=4+  mayRaise=[ExceptionFailure]+  alwaysRaise=[]+  freeRegs=[]+lift2Value (\x_0 -> \x_1 -> x_0 x_1)+  minReads=0+  mayRaise=[ExceptionFailure]+  alwaysRaise=[]+  freeRegs=[]+pushValue (\x_0 -> x_0)+  minReads=0+  mayRaise=[ExceptionFailure]+  alwaysRaise=[]+  freeRegs=[]+newRegister reg+  minReads=0+  mayRaise=[ExceptionFailure]+  alwaysRaise=[]+  freeRegs=[]+iter loop+  minReads=0+  mayRaise=[ExceptionFailure]+  alwaysRaise=[]+  freeRegs=[reg]+| <ok>+| | pushValue (GHC.Types.:)+| |   minReads=4+| |   mayRaise=[ExceptionFailure]+| |   alwaysRaise=[]+| |   freeRegs=[reg]+| | call name+| |   minReads=4+| |   mayRaise=[ExceptionFailure]+| |   alwaysRaise=[]+| |   freeRegs=[reg]+| | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| |   minReads=0+| |   mayRaise=[]+| |   alwaysRaise=[]+| |   freeRegs=[reg]+| | pushValue (\x_0 -> \x_1 -> \x_2 -> x_1 (x_0 x_2))+| |   minReads=0+| |   mayRaise=[]+| |   alwaysRaise=[]+| |   freeRegs=[reg]+| | lift2Value (\x_0 -> \x_1 -> x_1 x_0)+| |   minReads=0+| |   mayRaise=[]+| |   alwaysRaise=[]+| |   freeRegs=[reg]+| | readRegister reg+| |   minReads=0+| |   mayRaise=[]+| |   alwaysRaise=[]+| |   freeRegs=[reg]+| | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| |   minReads=0+| |   mayRaise=[]+| |   alwaysRaise=[]+| |   freeRegs=[reg]+| | writeRegister reg+| |   minReads=0+| |   mayRaise=[]+| |   alwaysRaise=[]+| |   freeRegs=[reg]+| | jump loop+| |   minReads=0+| |   mayRaise=[]+| |   alwaysRaise=[]+| |   freeRegs=[]+| <ko>+| | comment "raiseAgainIfConsumed"+| |   minReads=0+| |   mayRaise=[ExceptionFailure]+| |   alwaysRaise=[]+| |   freeRegs=[reg]+| | saveInput+| |   minReads=0+| |   mayRaise=[ExceptionFailure]+| |   alwaysRaise=[]+| |   freeRegs=[reg]+| | lift2Value (\(Data.Text.Internal.Text _ i_0 _) (Data.Text.Internal.Text _+| |                                                                j_1+| |                                                                _) -> i_0 GHC.Classes.== j_1)+| |   minReads=0+| |   mayRaise=[ExceptionFailure]+| |   alwaysRaise=[]+| |   freeRegs=[reg]+| | choicesBranch+| |   minReads=0+| |   mayRaise=[ExceptionFailure]+| |   alwaysRaise=[]+| |   freeRegs=[reg]+| | | <branch (\x_0 -> x_0)>+| | | | readRegister reg+| | | |   minReads=0+| | | |   mayRaise=[]+| | | |   alwaysRaise=[]+| | | |   freeRegs=[reg]+| | | | pushValue GHC.Types.[]+| | | |   minReads=0+| | | |   mayRaise=[]+| | | |   alwaysRaise=[]+| | | |   freeRegs=[]+| | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| | | |   minReads=0+| | | |   mayRaise=[]+| | | |   alwaysRaise=[]+| | | |   freeRegs=[]+| | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| | | |   minReads=0+| | | |   mayRaise=[]+| | | |   alwaysRaise=[]+| | | |   freeRegs=[]+| | | | ret+| | | |   minReads=0+| | | |   mayRaise=[]+| | | |   alwaysRaise=[]+| | | |   freeRegs=[]+| | | <default>+| | | | fail []+| | | |   minReads=0+| | | |   mayRaise=[ExceptionFailure]+| | | |   alwaysRaise=[ExceptionFailure]+| | | |   freeRegs=[]
+ tests/Golden/Machine/G5.expected.txt view
@@ -0,0 +1,361 @@+let name+  minReads=4+  mayRaise=[ExceptionFailure]+  alwaysRaise=[]+  freeRegs=[]+| catch ExceptionFailure+|   minReads=4+|   mayRaise=[ExceptionFailure]+|   alwaysRaise=[]+|   freeRegs=[]+| | <catchScope>+| | | pushValue (\x_0 -> \x_1 -> \x_2 -> \x_3 -> (GHC.Types.:) 'a' ((GHC.Types.:) 'b' ((GHC.Types.:) 'c' ((GHC.Types.:) 'd' GHC.Types.[]))))+| | |   minReads=4+| | |   mayRaise=[ExceptionFailure]+| | |   alwaysRaise=[]+| | |   freeRegs=[]+| | | comment "satisfy ((GHC.Classes.==) 'a')"+| | |   minReads=4+| | |   mayRaise=[ExceptionFailure]+| | |   alwaysRaise=[]+| | |   freeRegs=[]+| | | read ((GHC.Classes.==) 'a')+| | |   minReads=4+| | |   mayRaise=[ExceptionFailure]+| | |   alwaysRaise=[]+| | |   freeRegs=[]+| | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| | |   minReads=3+| | |   mayRaise=[ExceptionFailure]+| | |   alwaysRaise=[]+| | |   freeRegs=[]+| | | comment "satisfy ((GHC.Classes.==) 'b')"+| | |   minReads=3+| | |   mayRaise=[ExceptionFailure]+| | |   alwaysRaise=[]+| | |   freeRegs=[]+| | | read ((GHC.Classes.==) 'b')+| | |   minReads=3+| | |   mayRaise=[ExceptionFailure]+| | |   alwaysRaise=[]+| | |   freeRegs=[]+| | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| | |   minReads=2+| | |   mayRaise=[ExceptionFailure]+| | |   alwaysRaise=[]+| | |   freeRegs=[]+| | | comment "satisfy ((GHC.Classes.==) 'c')"+| | |   minReads=2+| | |   mayRaise=[ExceptionFailure]+| | |   alwaysRaise=[]+| | |   freeRegs=[]+| | | read ((GHC.Classes.==) 'c')+| | |   minReads=2+| | |   mayRaise=[ExceptionFailure]+| | |   alwaysRaise=[]+| | |   freeRegs=[]+| | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| | |   minReads=1+| | |   mayRaise=[ExceptionFailure]+| | |   alwaysRaise=[]+| | |   freeRegs=[]+| | | comment "satisfy ((GHC.Classes.==) 'd')"+| | |   minReads=1+| | |   mayRaise=[ExceptionFailure]+| | |   alwaysRaise=[]+| | |   freeRegs=[]+| | | read ((GHC.Classes.==) 'd')+| | |   minReads=1+| | |   mayRaise=[ExceptionFailure]+| | |   alwaysRaise=[]+| | |   freeRegs=[]+| | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| | |   minReads=0+| | |   mayRaise=[]+| | |   alwaysRaise=[]+| | |   freeRegs=[]+| | | commit ExceptionFailure+| | |   minReads=0+| | |   mayRaise=[]+| | |   alwaysRaise=[]+| | |   freeRegs=[]+| | | ret+| | |   minReads=0+| | |   mayRaise=[]+| | |   alwaysRaise=[]+| | |   freeRegs=[]+| | <onException ExceptionFailure>+| | | loadInput+| | |   minReads=0+| | |   mayRaise=[ExceptionFailure]+| | |   alwaysRaise=[ExceptionFailure]+| | |   freeRegs=[]+| | | fail []+| | |   minReads=0+| | |   mayRaise=[ExceptionFailure]+| | |   alwaysRaise=[ExceptionFailure]+| | |   freeRegs=[]+pushValue (\x_0 -> \x_1 -> \x_2 -> GHC.Show.show ((GHC.Types.:) x_0 x_1))+  minReads=4+  mayRaise=[ExceptionFailure]+  alwaysRaise=[]+  freeRegs=[]+call name+  minReads=4+  mayRaise=[ExceptionFailure]+  alwaysRaise=[]+  freeRegs=[]+lift2Value (\x_0 -> \x_1 -> x_0 x_1)+  minReads=0+  mayRaise=[ExceptionFailure]+  alwaysRaise=[]+  freeRegs=[]+pushValue (\x_0 -> x_0)+  minReads=0+  mayRaise=[ExceptionFailure]+  alwaysRaise=[]+  freeRegs=[]+newRegister reg+  minReads=0+  mayRaise=[ExceptionFailure]+  alwaysRaise=[]+  freeRegs=[]+iter loop+  minReads=0+  mayRaise=[ExceptionFailure]+  alwaysRaise=[]+  freeRegs=[reg]+| <ok>+| | pushValue (GHC.Types.:)+| |   minReads=4+| |   mayRaise=[ExceptionFailure]+| |   alwaysRaise=[]+| |   freeRegs=[reg]+| | call name+| |   minReads=4+| |   mayRaise=[ExceptionFailure]+| |   alwaysRaise=[]+| |   freeRegs=[reg]+| | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| |   minReads=0+| |   mayRaise=[]+| |   alwaysRaise=[]+| |   freeRegs=[reg]+| | pushValue (\x_0 -> \x_1 -> \x_2 -> x_1 (x_0 x_2))+| |   minReads=0+| |   mayRaise=[]+| |   alwaysRaise=[]+| |   freeRegs=[reg]+| | lift2Value (\x_0 -> \x_1 -> x_1 x_0)+| |   minReads=0+| |   mayRaise=[]+| |   alwaysRaise=[]+| |   freeRegs=[reg]+| | readRegister reg+| |   minReads=0+| |   mayRaise=[]+| |   alwaysRaise=[]+| |   freeRegs=[reg]+| | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| |   minReads=0+| |   mayRaise=[]+| |   alwaysRaise=[]+| |   freeRegs=[reg]+| | writeRegister reg+| |   minReads=0+| |   mayRaise=[]+| |   alwaysRaise=[]+| |   freeRegs=[reg]+| | jump loop+| |   minReads=0+| |   mayRaise=[]+| |   alwaysRaise=[]+| |   freeRegs=[]+| <ko>+| | comment "raiseAgainIfConsumed"+| |   minReads=0+| |   mayRaise=[ExceptionFailure]+| |   alwaysRaise=[]+| |   freeRegs=[reg]+| | saveInput+| |   minReads=0+| |   mayRaise=[ExceptionFailure]+| |   alwaysRaise=[]+| |   freeRegs=[reg]+| | lift2Value (\(Data.Text.Internal.Text _ i_0 _) (Data.Text.Internal.Text _+| |                                                                j_1+| |                                                                _) -> i_0 GHC.Classes.== j_1)+| |   minReads=0+| |   mayRaise=[ExceptionFailure]+| |   alwaysRaise=[]+| |   freeRegs=[reg]+| | choicesBranch+| |   minReads=0+| |   mayRaise=[ExceptionFailure]+| |   alwaysRaise=[]+| |   freeRegs=[reg]+| | | <branch (\x_0 -> x_0)>+| | | | readRegister reg+| | | |   minReads=0+| | | |   mayRaise=[ExceptionFailure]+| | | |   alwaysRaise=[]+| | | |   freeRegs=[reg]+| | | | pushValue GHC.Types.[]+| | | |   minReads=0+| | | |   mayRaise=[ExceptionFailure]+| | | |   alwaysRaise=[]+| | | |   freeRegs=[]+| | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| | | |   minReads=0+| | | |   mayRaise=[ExceptionFailure]+| | | |   alwaysRaise=[]+| | | |   freeRegs=[]+| | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| | | |   minReads=0+| | | |   mayRaise=[ExceptionFailure]+| | | |   alwaysRaise=[]+| | | |   freeRegs=[]+| | | | join join+| | | |   minReads=0+| | | |   mayRaise=[]+| | | |   alwaysRaise=[]+| | | |   freeRegs=[]+| | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| | | | |   minReads=0+| | | | |   mayRaise=[]+| | | | |   alwaysRaise=[]+| | | | |   freeRegs=[]+| | | | | ret+| | | | |   minReads=0+| | | | |   mayRaise=[]+| | | | |   alwaysRaise=[]+| | | | |   freeRegs=[]+| | | | catch ExceptionFailure+| | | |   minReads=0+| | | |   mayRaise=[ExceptionFailure]+| | | |   alwaysRaise=[]+| | | |   freeRegs=[]+| | | | | <catchScope>+| | | | | | comment "negLook"+| | | | | |   minReads=0+| | | | | |   mayRaise=[]+| | | | | |   alwaysRaise=[]+| | | | | |   freeRegs=[]+| | | | | | catch ExceptionFailure+| | | | | |   minReads=0+| | | | | |   mayRaise=[]+| | | | | |   alwaysRaise=[]+| | | | | |   freeRegs=[]+| | | | | | | <catchScope>+| | | | | | | | comment "negLook.ahead"+| | | | | | | |   minReads=1+| | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | |   alwaysRaise=[ExceptionFailure]+| | | | | | | |   freeRegs=[]+| | | | | | | | saveInput+| | | | | | | |   minReads=1+| | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | |   alwaysRaise=[ExceptionFailure]+| | | | | | | |   freeRegs=[]+| | | | | | | | comment "satisfy ((\\x_0 -> \\x_1 -> x_0) GHC.Types.True)"+| | | | | | | |   minReads=1+| | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | |   alwaysRaise=[ExceptionFailure]+| | | | | | | |   freeRegs=[]+| | | | | | | | read (\x_0 -> GHC.Types.True)+| | | | | | | |   minReads=1+| | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | |   alwaysRaise=[ExceptionFailure]+| | | | | | | |   freeRegs=[]+| | | | | | | | popValue+| | | | | | | |   minReads=0+| | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | |   alwaysRaise=[ExceptionFailure]+| | | | | | | |   freeRegs=[]+| | | | | | | | commit ExceptionFailure+| | | | | | | |   minReads=0+| | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | |   alwaysRaise=[ExceptionFailure]+| | | | | | | |   freeRegs=[]+| | | | | | | | loadInput+| | | | | | | |   minReads=0+| | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | |   alwaysRaise=[ExceptionFailure]+| | | | | | | |   freeRegs=[]+| | | | | | | | fail []+| | | | | | | |   minReads=0+| | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | |   alwaysRaise=[ExceptionFailure]+| | | | | | | |   freeRegs=[]+| | | | | | | <onException ExceptionFailure>+| | | | | | | | comment "negLook.reset"+| | | | | | | |   minReads=0+| | | | | | | |   mayRaise=[]+| | | | | | | |   alwaysRaise=[]+| | | | | | | |   freeRegs=[]+| | | | | | | | loadInput+| | | | | | | |   minReads=0+| | | | | | | |   mayRaise=[]+| | | | | | | |   alwaysRaise=[]+| | | | | | | |   freeRegs=[]+| | | | | | | | pushValue GHC.Tuple.()+| | | | | | | |   minReads=0+| | | | | | | |   mayRaise=[]+| | | | | | | |   alwaysRaise=[]+| | | | | | | |   freeRegs=[]+| | | | | | | | commit ExceptionFailure+| | | | | | | |   minReads=0+| | | | | | | |   mayRaise=[]+| | | | | | | |   alwaysRaise=[]+| | | | | | | |   freeRegs=[]+| | | | | | | | refJoin join+| | | | | | | |   minReads=0+| | | | | | | |   mayRaise=[]+| | | | | | | |   alwaysRaise=[]+| | | | | | | |   freeRegs=[]+| | | | | <onException ExceptionFailure>+| | | | | | comment "raiseAgainIfConsumed"+| | | | | |   minReads=0+| | | | | |   mayRaise=[ExceptionFailure]+| | | | | |   alwaysRaise=[]+| | | | | |   freeRegs=[]+| | | | | | saveInput+| | | | | |   minReads=0+| | | | | |   mayRaise=[ExceptionFailure]+| | | | | |   alwaysRaise=[]+| | | | | |   freeRegs=[]+| | | | | | lift2Value (\(Data.Text.Internal.Text _ i_0 _) (Data.Text.Internal.Text _+| | | | | |                                                                j_1+| | | | | |                                                                _) -> i_0 GHC.Classes.== j_1)+| | | | | |   minReads=0+| | | | | |   mayRaise=[ExceptionFailure]+| | | | | |   alwaysRaise=[]+| | | | | |   freeRegs=[]+| | | | | | choicesBranch+| | | | | |   minReads=0+| | | | | |   mayRaise=[ExceptionFailure]+| | | | | |   alwaysRaise=[]+| | | | | |   freeRegs=[]+| | | | | | | <branch (\x_0 -> x_0)>+| | | | | | | | comment "eof.fail"+| | | | | | | |   minReads=0+| | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | |   alwaysRaise=[ExceptionFailure]+| | | | | | | |   freeRegs=[]+| | | | | | | | fail [FailureEnd]+| | | | | | | |   minReads=0+| | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | |   alwaysRaise=[ExceptionFailure]+| | | | | | | |   freeRegs=[]+| | | | | | | <default>+| | | | | | | | fail []+| | | | | | | |   minReads=0+| | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | |   alwaysRaise=[ExceptionFailure]+| | | | | | | |   freeRegs=[]+| | | <default>+| | | | fail []+| | | |   minReads=0+| | | |   mayRaise=[ExceptionFailure]+| | | |   alwaysRaise=[ExceptionFailure]+| | | |   freeRegs=[]
+ tests/Golden/Machine/G6.expected.txt view
@@ -0,0 +1,141 @@+pushValue GHC.Show.show+  minReads=2+  mayRaise=[ExceptionFailure]+  alwaysRaise=[]+  freeRegs=[]+join join+  minReads=0+  mayRaise=[]+  alwaysRaise=[]+  freeRegs=[]+| lift2Value (\x_0 -> \x_1 -> x_0 x_1)+|   minReads=0+|   mayRaise=[]+|   alwaysRaise=[]+|   freeRegs=[]+| ret+|   minReads=0+|   mayRaise=[]+|   alwaysRaise=[]+|   freeRegs=[]+catch ExceptionFailure+  minReads=2+  mayRaise=[ExceptionFailure]+  alwaysRaise=[]+  freeRegs=[]+| <catchScope>+| | pushValue (\x_0 -> \x_1 -> (GHC.Types.:) 'a' ((GHC.Types.:) 'a' GHC.Types.[]))+| |   minReads=2+| |   mayRaise=[ExceptionFailure]+| |   alwaysRaise=[]+| |   freeRegs=[]+| | comment "satisfy ((GHC.Classes.==) 'a')"+| |   minReads=2+| |   mayRaise=[ExceptionFailure]+| |   alwaysRaise=[]+| |   freeRegs=[]+| | read ((GHC.Classes.==) 'a')+| |   minReads=2+| |   mayRaise=[ExceptionFailure]+| |   alwaysRaise=[]+| |   freeRegs=[]+| | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| |   minReads=1+| |   mayRaise=[ExceptionFailure]+| |   alwaysRaise=[]+| |   freeRegs=[]+| | comment "satisfy ((GHC.Classes.==) 'a')"+| |   minReads=1+| |   mayRaise=[ExceptionFailure]+| |   alwaysRaise=[]+| |   freeRegs=[]+| | read ((GHC.Classes.==) 'a')+| |   minReads=1+| |   mayRaise=[ExceptionFailure]+| |   alwaysRaise=[]+| |   freeRegs=[]+| | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| |   minReads=0+| |   mayRaise=[]+| |   alwaysRaise=[]+| |   freeRegs=[]+| | commit ExceptionFailure+| |   minReads=0+| |   mayRaise=[]+| |   alwaysRaise=[]+| |   freeRegs=[]+| | refJoin join+| |   minReads=0+| |   mayRaise=[]+| |   alwaysRaise=[]+| |   freeRegs=[]+| <onException ExceptionFailure>+| | comment "raiseAgainIfConsumed"+| |   minReads=2+| |   mayRaise=[ExceptionFailure]+| |   alwaysRaise=[]+| |   freeRegs=[]+| | saveInput+| |   minReads=2+| |   mayRaise=[ExceptionFailure]+| |   alwaysRaise=[]+| |   freeRegs=[]+| | lift2Value (\(Data.Text.Internal.Text _ i_0 _) (Data.Text.Internal.Text _+| |                                                                j_1+| |                                                                _) -> i_0 GHC.Classes.== j_1)+| |   minReads=2+| |   mayRaise=[ExceptionFailure]+| |   alwaysRaise=[]+| |   freeRegs=[]+| | choicesBranch+| |   minReads=2+| |   mayRaise=[ExceptionFailure]+| |   alwaysRaise=[]+| |   freeRegs=[]+| | | <branch (\x_0 -> x_0)>+| | | | pushValue (\x_0 -> \x_1 -> (GHC.Types.:) 'a' ((GHC.Types.:) 'b' GHC.Types.[]))+| | | |   minReads=2+| | | |   mayRaise=[ExceptionFailure]+| | | |   alwaysRaise=[]+| | | |   freeRegs=[]+| | | | comment "satisfy ((GHC.Classes.==) 'a')"+| | | |   minReads=2+| | | |   mayRaise=[ExceptionFailure]+| | | |   alwaysRaise=[]+| | | |   freeRegs=[]+| | | | read ((GHC.Classes.==) 'a')+| | | |   minReads=2+| | | |   mayRaise=[ExceptionFailure]+| | | |   alwaysRaise=[]+| | | |   freeRegs=[]+| | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| | | |   minReads=1+| | | |   mayRaise=[ExceptionFailure]+| | | |   alwaysRaise=[]+| | | |   freeRegs=[]+| | | | comment "satisfy ((GHC.Classes.==) 'b')"+| | | |   minReads=1+| | | |   mayRaise=[ExceptionFailure]+| | | |   alwaysRaise=[]+| | | |   freeRegs=[]+| | | | read ((GHC.Classes.==) 'b')+| | | |   minReads=1+| | | |   mayRaise=[ExceptionFailure]+| | | |   alwaysRaise=[]+| | | |   freeRegs=[]+| | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| | | |   minReads=0+| | | |   mayRaise=[]+| | | |   alwaysRaise=[]+| | | |   freeRegs=[]+| | | | refJoin join+| | | |   minReads=0+| | | |   mayRaise=[]+| | | |   alwaysRaise=[]+| | | |   freeRegs=[]+| | | <default>+| | | | fail []+| | | |   minReads=0+| | | |   mayRaise=[ExceptionFailure]+| | | |   alwaysRaise=[ExceptionFailure]+| | | |   freeRegs=[]
+ tests/Golden/Machine/G7.expected.txt view
@@ -0,0 +1,185 @@+pushValue GHC.Show.show+  minReads=2+  mayRaise=[ExceptionFailure]+  alwaysRaise=[]+  freeRegs=[]+join join+  minReads=0+  mayRaise=[]+  alwaysRaise=[]+  freeRegs=[]+| lift2Value (\x_0 -> \x_1 -> x_0 x_1)+|   minReads=0+|   mayRaise=[]+|   alwaysRaise=[]+|   freeRegs=[]+| ret+|   minReads=0+|   mayRaise=[]+|   alwaysRaise=[]+|   freeRegs=[]+catch ExceptionFailure+  minReads=2+  mayRaise=[ExceptionFailure]+  alwaysRaise=[]+  freeRegs=[]+| <catchScope>+| | catch ExceptionFailure+| |   minReads=2+| |   mayRaise=[ExceptionFailure]+| |   alwaysRaise=[]+| |   freeRegs=[]+| | | <catchScope>+| | | | pushValue (\x_0 -> \x_1 -> (GHC.Types.:) 'a' ((GHC.Types.:) 'a' GHC.Types.[]))+| | | |   minReads=2+| | | |   mayRaise=[ExceptionFailure]+| | | |   alwaysRaise=[]+| | | |   freeRegs=[]+| | | | comment "satisfy ((GHC.Classes.==) 'a')"+| | | |   minReads=2+| | | |   mayRaise=[ExceptionFailure]+| | | |   alwaysRaise=[]+| | | |   freeRegs=[]+| | | | read ((GHC.Classes.==) 'a')+| | | |   minReads=2+| | | |   mayRaise=[ExceptionFailure]+| | | |   alwaysRaise=[]+| | | |   freeRegs=[]+| | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| | | |   minReads=1+| | | |   mayRaise=[ExceptionFailure]+| | | |   alwaysRaise=[]+| | | |   freeRegs=[]+| | | | comment "satisfy ((GHC.Classes.==) 'a')"+| | | |   minReads=1+| | | |   mayRaise=[ExceptionFailure]+| | | |   alwaysRaise=[]+| | | |   freeRegs=[]+| | | | read ((GHC.Classes.==) 'a')+| | | |   minReads=1+| | | |   mayRaise=[ExceptionFailure]+| | | |   alwaysRaise=[]+| | | |   freeRegs=[]+| | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| | | |   minReads=0+| | | |   mayRaise=[]+| | | |   alwaysRaise=[]+| | | |   freeRegs=[]+| | | | commit ExceptionFailure+| | | |   minReads=0+| | | |   mayRaise=[]+| | | |   alwaysRaise=[]+| | | |   freeRegs=[]+| | | | commit ExceptionFailure+| | | |   minReads=0+| | | |   mayRaise=[]+| | | |   alwaysRaise=[]+| | | |   freeRegs=[]+| | | | refJoin join+| | | |   minReads=0+| | | |   mayRaise=[]+| | | |   alwaysRaise=[]+| | | |   freeRegs=[]+| | | <onException ExceptionFailure>+| | | | loadInput+| | | |   minReads=0+| | | |   mayRaise=[ExceptionFailure]+| | | |   alwaysRaise=[ExceptionFailure]+| | | |   freeRegs=[]+| | | | fail []+| | | |   minReads=0+| | | |   mayRaise=[ExceptionFailure]+| | | |   alwaysRaise=[ExceptionFailure]+| | | |   freeRegs=[]+| <onException ExceptionFailure>+| | comment "raiseAgainIfConsumed"+| |   minReads=2+| |   mayRaise=[ExceptionFailure]+| |   alwaysRaise=[]+| |   freeRegs=[]+| | saveInput+| |   minReads=2+| |   mayRaise=[ExceptionFailure]+| |   alwaysRaise=[]+| |   freeRegs=[]+| | lift2Value (\(Data.Text.Internal.Text _ i_0 _) (Data.Text.Internal.Text _+| |                                                                j_1+| |                                                                _) -> i_0 GHC.Classes.== j_1)+| |   minReads=2+| |   mayRaise=[ExceptionFailure]+| |   alwaysRaise=[]+| |   freeRegs=[]+| | choicesBranch+| |   minReads=2+| |   mayRaise=[ExceptionFailure]+| |   alwaysRaise=[]+| |   freeRegs=[]+| | | <branch (\x_0 -> x_0)>+| | | | catch ExceptionFailure+| | | |   minReads=2+| | | |   mayRaise=[ExceptionFailure]+| | | |   alwaysRaise=[]+| | | |   freeRegs=[]+| | | | | <catchScope>+| | | | | | pushValue (\x_0 -> \x_1 -> (GHC.Types.:) 'a' ((GHC.Types.:) 'b' GHC.Types.[]))+| | | | | |   minReads=2+| | | | | |   mayRaise=[ExceptionFailure]+| | | | | |   alwaysRaise=[]+| | | | | |   freeRegs=[]+| | | | | | comment "satisfy ((GHC.Classes.==) 'a')"+| | | | | |   minReads=2+| | | | | |   mayRaise=[ExceptionFailure]+| | | | | |   alwaysRaise=[]+| | | | | |   freeRegs=[]+| | | | | | read ((GHC.Classes.==) 'a')+| | | | | |   minReads=2+| | | | | |   mayRaise=[ExceptionFailure]+| | | | | |   alwaysRaise=[]+| | | | | |   freeRegs=[]+| | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| | | | | |   minReads=1+| | | | | |   mayRaise=[ExceptionFailure]+| | | | | |   alwaysRaise=[]+| | | | | |   freeRegs=[]+| | | | | | comment "satisfy ((GHC.Classes.==) 'b')"+| | | | | |   minReads=1+| | | | | |   mayRaise=[ExceptionFailure]+| | | | | |   alwaysRaise=[]+| | | | | |   freeRegs=[]+| | | | | | read ((GHC.Classes.==) 'b')+| | | | | |   minReads=1+| | | | | |   mayRaise=[ExceptionFailure]+| | | | | |   alwaysRaise=[]+| | | | | |   freeRegs=[]+| | | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| | | | | |   minReads=0+| | | | | |   mayRaise=[]+| | | | | |   alwaysRaise=[]+| | | | | |   freeRegs=[]+| | | | | | commit ExceptionFailure+| | | | | |   minReads=0+| | | | | |   mayRaise=[]+| | | | | |   alwaysRaise=[]+| | | | | |   freeRegs=[]+| | | | | | refJoin join+| | | | | |   minReads=0+| | | | | |   mayRaise=[]+| | | | | |   alwaysRaise=[]+| | | | | |   freeRegs=[]+| | | | | <onException ExceptionFailure>+| | | | | | loadInput+| | | | | |   minReads=0+| | | | | |   mayRaise=[ExceptionFailure]+| | | | | |   alwaysRaise=[ExceptionFailure]+| | | | | |   freeRegs=[]+| | | | | | fail []+| | | | | |   minReads=0+| | | | | |   mayRaise=[ExceptionFailure]+| | | | | |   alwaysRaise=[ExceptionFailure]+| | | | | |   freeRegs=[]+| | | <default>+| | | | fail []+| | | |   minReads=0+| | | |   mayRaise=[ExceptionFailure]+| | | |   alwaysRaise=[ExceptionFailure]+| | | |   freeRegs=[]
+ tests/Golden/Machine/G8.expected.txt view
@@ -0,0 +1,259 @@+pushValue (\x_0 -> \x_1 -> GHC.Show.show x_0)+  minReads=0+  mayRaise=[ExceptionFailure]+  alwaysRaise=[]+  freeRegs=[]+pushValue (\x_0 -> x_0)+  minReads=0+  mayRaise=[ExceptionFailure]+  alwaysRaise=[]+  freeRegs=[]+newRegister reg+  minReads=0+  mayRaise=[ExceptionFailure]+  alwaysRaise=[]+  freeRegs=[]+iter loop+  minReads=0+  mayRaise=[ExceptionFailure]+  alwaysRaise=[]+  freeRegs=[reg]+| <ok>+| | pushValue (\x_0 -> (GHC.Types.:) 'r')+| |   minReads=1+| |   mayRaise=[ExceptionFailure]+| |   alwaysRaise=[]+| |   freeRegs=[reg]+| | comment "satisfy ((GHC.Classes.==) 'r')"+| |   minReads=1+| |   mayRaise=[ExceptionFailure]+| |   alwaysRaise=[]+| |   freeRegs=[reg]+| | read ((GHC.Classes.==) 'r')+| |   minReads=1+| |   mayRaise=[ExceptionFailure]+| |   alwaysRaise=[]+| |   freeRegs=[reg]+| | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| |   minReads=0+| |   mayRaise=[]+| |   alwaysRaise=[]+| |   freeRegs=[reg]+| | pushValue (\x_0 -> \x_1 -> \x_2 -> x_1 (x_0 x_2))+| |   minReads=0+| |   mayRaise=[]+| |   alwaysRaise=[]+| |   freeRegs=[reg]+| | lift2Value (\x_0 -> \x_1 -> x_1 x_0)+| |   minReads=0+| |   mayRaise=[]+| |   alwaysRaise=[]+| |   freeRegs=[reg]+| | readRegister reg+| |   minReads=0+| |   mayRaise=[]+| |   alwaysRaise=[]+| |   freeRegs=[reg]+| | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| |   minReads=0+| |   mayRaise=[]+| |   alwaysRaise=[]+| |   freeRegs=[reg]+| | writeRegister reg+| |   minReads=0+| |   mayRaise=[]+| |   alwaysRaise=[]+| |   freeRegs=[reg]+| | jump loop+| |   minReads=0+| |   mayRaise=[]+| |   alwaysRaise=[]+| |   freeRegs=[]+| <ko>+| | comment "raiseAgainIfConsumed"+| |   minReads=0+| |   mayRaise=[ExceptionFailure]+| |   alwaysRaise=[]+| |   freeRegs=[reg]+| | saveInput+| |   minReads=0+| |   mayRaise=[ExceptionFailure]+| |   alwaysRaise=[]+| |   freeRegs=[reg]+| | lift2Value (\(Data.Text.Internal.Text _ i_0 _) (Data.Text.Internal.Text _+| |                                                                j_1+| |                                                                _) -> i_0 GHC.Classes.== j_1)+| |   minReads=0+| |   mayRaise=[ExceptionFailure]+| |   alwaysRaise=[]+| |   freeRegs=[reg]+| | choicesBranch+| |   minReads=0+| |   mayRaise=[ExceptionFailure]+| |   alwaysRaise=[]+| |   freeRegs=[reg]+| | | <branch (\x_0 -> x_0)>+| | | | readRegister reg+| | | |   minReads=0+| | | |   mayRaise=[ExceptionFailure]+| | | |   alwaysRaise=[]+| | | |   freeRegs=[reg]+| | | | pushValue GHC.Types.[]+| | | |   minReads=0+| | | |   mayRaise=[ExceptionFailure]+| | | |   alwaysRaise=[]+| | | |   freeRegs=[]+| | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| | | |   minReads=0+| | | |   mayRaise=[ExceptionFailure]+| | | |   alwaysRaise=[]+| | | |   freeRegs=[]+| | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| | | |   minReads=0+| | | |   mayRaise=[ExceptionFailure]+| | | |   alwaysRaise=[]+| | | |   freeRegs=[]+| | | | join join+| | | |   minReads=0+| | | |   mayRaise=[]+| | | |   alwaysRaise=[]+| | | |   freeRegs=[]+| | | | | lift2Value (\x_0 -> \x_1 -> x_0 x_1)+| | | | |   minReads=0+| | | | |   mayRaise=[]+| | | | |   alwaysRaise=[]+| | | | |   freeRegs=[]+| | | | | ret+| | | | |   minReads=0+| | | | |   mayRaise=[]+| | | | |   alwaysRaise=[]+| | | | |   freeRegs=[]+| | | | catch ExceptionFailure+| | | |   minReads=0+| | | |   mayRaise=[ExceptionFailure]+| | | |   alwaysRaise=[]+| | | |   freeRegs=[]+| | | | | <catchScope>+| | | | | | comment "negLook"+| | | | | |   minReads=0+| | | | | |   mayRaise=[]+| | | | | |   alwaysRaise=[]+| | | | | |   freeRegs=[]+| | | | | | catch ExceptionFailure+| | | | | |   minReads=0+| | | | | |   mayRaise=[]+| | | | | |   alwaysRaise=[]+| | | | | |   freeRegs=[]+| | | | | | | <catchScope>+| | | | | | | | comment "negLook.ahead"+| | | | | | | |   minReads=1+| | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | |   alwaysRaise=[ExceptionFailure]+| | | | | | | |   freeRegs=[]+| | | | | | | | saveInput+| | | | | | | |   minReads=1+| | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | |   alwaysRaise=[ExceptionFailure]+| | | | | | | |   freeRegs=[]+| | | | | | | | comment "satisfy ((\\x_0 -> \\x_1 -> x_0) GHC.Types.True)"+| | | | | | | |   minReads=1+| | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | |   alwaysRaise=[ExceptionFailure]+| | | | | | | |   freeRegs=[]+| | | | | | | | read (\x_0 -> GHC.Types.True)+| | | | | | | |   minReads=1+| | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | |   alwaysRaise=[ExceptionFailure]+| | | | | | | |   freeRegs=[]+| | | | | | | | popValue+| | | | | | | |   minReads=0+| | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | |   alwaysRaise=[ExceptionFailure]+| | | | | | | |   freeRegs=[]+| | | | | | | | commit ExceptionFailure+| | | | | | | |   minReads=0+| | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | |   alwaysRaise=[ExceptionFailure]+| | | | | | | |   freeRegs=[]+| | | | | | | | loadInput+| | | | | | | |   minReads=0+| | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | |   alwaysRaise=[ExceptionFailure]+| | | | | | | |   freeRegs=[]+| | | | | | | | fail []+| | | | | | | |   minReads=0+| | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | |   alwaysRaise=[ExceptionFailure]+| | | | | | | |   freeRegs=[]+| | | | | | | <onException ExceptionFailure>+| | | | | | | | comment "negLook.reset"+| | | | | | | |   minReads=0+| | | | | | | |   mayRaise=[]+| | | | | | | |   alwaysRaise=[]+| | | | | | | |   freeRegs=[]+| | | | | | | | loadInput+| | | | | | | |   minReads=0+| | | | | | | |   mayRaise=[]+| | | | | | | |   alwaysRaise=[]+| | | | | | | |   freeRegs=[]+| | | | | | | | pushValue GHC.Tuple.()+| | | | | | | |   minReads=0+| | | | | | | |   mayRaise=[]+| | | | | | | |   alwaysRaise=[]+| | | | | | | |   freeRegs=[]+| | | | | | | | commit ExceptionFailure+| | | | | | | |   minReads=0+| | | | | | | |   mayRaise=[]+| | | | | | | |   alwaysRaise=[]+| | | | | | | |   freeRegs=[]+| | | | | | | | refJoin join+| | | | | | | |   minReads=0+| | | | | | | |   mayRaise=[]+| | | | | | | |   alwaysRaise=[]+| | | | | | | |   freeRegs=[]+| | | | | <onException ExceptionFailure>+| | | | | | comment "raiseAgainIfConsumed"+| | | | | |   minReads=0+| | | | | |   mayRaise=[ExceptionFailure]+| | | | | |   alwaysRaise=[]+| | | | | |   freeRegs=[]+| | | | | | saveInput+| | | | | |   minReads=0+| | | | | |   mayRaise=[ExceptionFailure]+| | | | | |   alwaysRaise=[]+| | | | | |   freeRegs=[]+| | | | | | lift2Value (\(Data.Text.Internal.Text _ i_0 _) (Data.Text.Internal.Text _+| | | | | |                                                                j_1+| | | | | |                                                                _) -> i_0 GHC.Classes.== j_1)+| | | | | |   minReads=0+| | | | | |   mayRaise=[ExceptionFailure]+| | | | | |   alwaysRaise=[]+| | | | | |   freeRegs=[]+| | | | | | choicesBranch+| | | | | |   minReads=0+| | | | | |   mayRaise=[ExceptionFailure]+| | | | | |   alwaysRaise=[]+| | | | | |   freeRegs=[]+| | | | | | | <branch (\x_0 -> x_0)>+| | | | | | | | comment "eof.fail"+| | | | | | | |   minReads=0+| | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | |   alwaysRaise=[ExceptionFailure]+| | | | | | | |   freeRegs=[]+| | | | | | | | fail [FailureEnd]+| | | | | | | |   minReads=0+| | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | |   alwaysRaise=[ExceptionFailure]+| | | | | | | |   freeRegs=[]+| | | | | | | <default>+| | | | | | | | fail []+| | | | | | | |   minReads=0+| | | | | | | |   mayRaise=[ExceptionFailure]+| | | | | | | |   alwaysRaise=[ExceptionFailure]+| | | | | | | |   freeRegs=[]+| | | <default>+| | | | fail []+| | | |   minReads=0+| | | |   mayRaise=[ExceptionFailure]+| | | |   alwaysRaise=[ExceptionFailure]+| | | |   freeRegs=[]
+ tests/Golden/Machine/G9.expected.txt view
@@ -0,0 +1,143 @@+pushValue GHC.Show.show+  minReads=0+  mayRaise=[ExceptionFailure]+  alwaysRaise=[]+  freeRegs=[]+join join+  minReads=0+  mayRaise=[]+  alwaysRaise=[]+  freeRegs=[]+| lift2Value (\x_0 -> \x_1 -> x_0 x_1)+|   minReads=0+|   mayRaise=[]+|   alwaysRaise=[]+|   freeRegs=[]+| ret+|   minReads=0+|   mayRaise=[]+|   alwaysRaise=[]+|   freeRegs=[]+catch ExceptionFailure+  minReads=0+  mayRaise=[ExceptionFailure]+  alwaysRaise=[]+  freeRegs=[]+| <catchScope>+| | comment "negLook"+| |   minReads=0+| |   mayRaise=[]+| |   alwaysRaise=[]+| |   freeRegs=[]+| | catch ExceptionFailure+| |   minReads=0+| |   mayRaise=[]+| |   alwaysRaise=[]+| |   freeRegs=[]+| | | <catchScope>+| | | | comment "negLook.ahead"+| | | |   minReads=1+| | | |   mayRaise=[ExceptionFailure]+| | | |   alwaysRaise=[ExceptionFailure]+| | | |   freeRegs=[]+| | | | saveInput+| | | |   minReads=1+| | | |   mayRaise=[ExceptionFailure]+| | | |   alwaysRaise=[ExceptionFailure]+| | | |   freeRegs=[]+| | | | comment "satisfy ((\\x_0 -> \\x_1 -> x_0) GHC.Types.True)"+| | | |   minReads=1+| | | |   mayRaise=[ExceptionFailure]+| | | |   alwaysRaise=[ExceptionFailure]+| | | |   freeRegs=[]+| | | | read (\x_0 -> GHC.Types.True)+| | | |   minReads=1+| | | |   mayRaise=[ExceptionFailure]+| | | |   alwaysRaise=[ExceptionFailure]+| | | |   freeRegs=[]+| | | | popValue+| | | |   minReads=0+| | | |   mayRaise=[ExceptionFailure]+| | | |   alwaysRaise=[ExceptionFailure]+| | | |   freeRegs=[]+| | | | commit ExceptionFailure+| | | |   minReads=0+| | | |   mayRaise=[ExceptionFailure]+| | | |   alwaysRaise=[ExceptionFailure]+| | | |   freeRegs=[]+| | | | loadInput+| | | |   minReads=0+| | | |   mayRaise=[ExceptionFailure]+| | | |   alwaysRaise=[ExceptionFailure]+| | | |   freeRegs=[]+| | | | fail []+| | | |   minReads=0+| | | |   mayRaise=[ExceptionFailure]+| | | |   alwaysRaise=[ExceptionFailure]+| | | |   freeRegs=[]+| | | <onException ExceptionFailure>+| | | | comment "negLook.reset"+| | | |   minReads=0+| | | |   mayRaise=[]+| | | |   alwaysRaise=[]+| | | |   freeRegs=[]+| | | | loadInput+| | | |   minReads=0+| | | |   mayRaise=[]+| | | |   alwaysRaise=[]+| | | |   freeRegs=[]+| | | | pushValue GHC.Tuple.()+| | | |   minReads=0+| | | |   mayRaise=[]+| | | |   alwaysRaise=[]+| | | |   freeRegs=[]+| | | | commit ExceptionFailure+| | | |   minReads=0+| | | |   mayRaise=[]+| | | |   alwaysRaise=[]+| | | |   freeRegs=[]+| | | | refJoin join+| | | |   minReads=0+| | | |   mayRaise=[]+| | | |   alwaysRaise=[]+| | | |   freeRegs=[]+| <onException ExceptionFailure>+| | comment "raiseAgainIfConsumed"+| |   minReads=0+| |   mayRaise=[ExceptionFailure]+| |   alwaysRaise=[]+| |   freeRegs=[]+| | saveInput+| |   minReads=0+| |   mayRaise=[ExceptionFailure]+| |   alwaysRaise=[]+| |   freeRegs=[]+| | lift2Value (\(Data.Text.Internal.Text _ i_0 _) (Data.Text.Internal.Text _+| |                                                                j_1+| |                                                                _) -> i_0 GHC.Classes.== j_1)+| |   minReads=0+| |   mayRaise=[ExceptionFailure]+| |   alwaysRaise=[]+| |   freeRegs=[]+| | choicesBranch+| |   minReads=0+| |   mayRaise=[ExceptionFailure]+| |   alwaysRaise=[]+| |   freeRegs=[]+| | | <branch (\x_0 -> x_0)>+| | | | comment "eof.fail"+| | | |   minReads=0+| | | |   mayRaise=[ExceptionFailure]+| | | |   alwaysRaise=[ExceptionFailure]+| | | |   freeRegs=[]+| | | | fail [FailureEnd]+| | | |   minReads=0+| | | |   mayRaise=[ExceptionFailure]+| | | |   alwaysRaise=[ExceptionFailure]+| | | |   freeRegs=[]+| | | <default>+| | | | fail []+| | | |   minReads=0+| | | |   mayRaise=[ExceptionFailure]+| | | |   alwaysRaise=[ExceptionFailure]+| | | |   freeRegs=[]
+ tests/Golden/Parser.hs view
@@ -0,0 +1,91 @@+{-# LANGUAGE DataKinds #-} -- For using P.viewGrammar+{-# LANGUAGE FlexibleContexts #-} -- For using P.Grammar Char+{-# LANGUAGE Rank2Types #-}+{-# LANGUAGE TypeApplications #-}+-- For TH splices+{-# LANGUAGE TemplateHaskell #-}+{-# LANGUAGE Rank2Types #-}+{-# LANGUAGE ScopedTypeVariables #-}+{-# LANGUAGE UnboxedTuples #-}+{-# OPTIONS_GHC -Wno-missing-signatures #-}+{-# OPTIONS_GHC -Wno-unused-local-binds #-}+{-# OPTIONS_GHC -Wno-unused-matches #-}+module Golden.Parser where++import Control.Monad (Monad(..))+import Data.Either (Either(..))+import Data.Function (($))+import Data.Functor ((<$>))+import Data.Int (Int)+import Data.Semigroup (Semigroup(..))+import Data.String (String, IsString(..))+import Data.Text (Text)+import Data.Text.IO (readFile)+import System.FilePath ((<.>), (</>), dropExtensions, takeBaseName)+import System.IO.Unsafe (unsafePerformIO)+import Test.Tasty+import Test.Tasty.Golden+import Text.Show (Show(..))+import qualified Control.Exception as IO+import qualified Data.List as List+import qualified System.Directory as IO+import qualified System.IO.Error as IO+import qualified Language.Haskell.TH as TH++import qualified Symantic.Parser as P+import Golden.Utils+import Golden.Splice++goldens :: TestTree+goldens = testGroup "Parser" $+  (\f -> List.zipWith f parsers [1::Int ..]) $ \p g ->+  -- Collect the existing files: tests/Golden/Parser/G*.input.txt+  let parserDir = getGoldenDir $ "Parser/G"<>show g in+  let inputs =+        ((parserDir </>) <$>) $+        List.sort $+        List.filter (List.isSuffixOf ".input.txt") $+        unsafePerformIO $+          IO.catchIOError+            (IO.listDirectory parserDir)+            (\exn ->+              if IO.isDoesNotExistError exn+              then return []+              else IO.throwIO exn+            ) in+  testGroup ("G"<>show g) $ (<$> inputs) $ \inp ->+    goldenVsStringDiff (takeBaseName (dropExtensions inp)) goldenDiff+      (dropExtensions inp<.>"expected.txt") $ do+      input <- readFile inp+      return $ fromString $+        case p input of+          Left err -> show err+          Right a -> a++parsers :: [Text -> Either (P.ParsingError Text) String]+parsers =+  [ p1, p2, p3, p4, p5, p6, p7, p8, p9+  , p10, p11, p12, p13, p14, p15, p16, p17, p18, p19+  , p20+  ]++p1 = $$(TH.Code $ TH.runIO s1)+p2 = $$(TH.Code $ TH.runIO s2)+p3 = $$(TH.Code $ TH.runIO s3)+p4 = $$(TH.Code $ TH.runIO s4)+p5 = $$(TH.Code $ TH.runIO s5)+p6 = $$(TH.Code $ TH.runIO s6)+p7 = $$(TH.Code $ TH.runIO s7)+p8 = $$(TH.Code $ TH.runIO s8)+p9 = $$(TH.Code $ TH.runIO s9)+p10 = $$(TH.Code $ TH.runIO s10)+p11 = $$(TH.Code $ TH.runIO s11)+p12 = $$(TH.Code $ TH.runIO s12)+p13 = $$(TH.Code $ TH.runIO s13)+p14 = $$(TH.Code $ TH.runIO s14)+p15 = $$(TH.Code $ TH.runIO s15)+p16 = $$(TH.Code $ TH.runIO s16)+p17 = $$(TH.Code $ TH.runIO s17)+p18 = $$(TH.Code $ TH.runIO s18)+p19 = $$(TH.Code $ TH.runIO s19)+p20 = $$(TH.Code $ TH.runIO s20)
+ tests/Golden/Parser/G1/P1.expected.txt view
@@ -0,0 +1,1 @@+'a'
+ tests/Golden/Parser/G1/P1.input.txt view
@@ -0,0 +1,1 @@+a
+ tests/Golden/Parser/G10/P1.expected.txt view
@@ -0,0 +1,1 @@+ParsingErrorStandard {parsingErrorOffset = 0, parsingErrorException = ExceptionFailure, parsingErrorUnexpected = Just 'c', parsingErrorExpecting = fromList [FailureToken 'a',FailureToken 'b']}
+ tests/Golden/Parser/G10/P1.input.txt view
@@ -0,0 +1,1 @@+c
+ tests/Golden/Parser/G11/P1.expected.txt view
@@ -0,0 +1,1 @@+ParsingErrorStandard {parsingErrorOffset = 4, parsingErrorException = ExceptionFailure, parsingErrorUnexpected = Just 'c', parsingErrorExpecting = fromList [FailureToken 'a',FailureToken 'b']}
+ tests/Golden/Parser/G11/P1.input.txt view
@@ -0,0 +1,1 @@+aaaac
+ tests/Golden/Parser/G12/P1.expected.txt view
@@ -0,0 +1,1 @@+"baacbccbaa"
+ tests/Golden/Parser/G12/P1.input.txt view
@@ -0,0 +1,1 @@+baacbccbaa
+ tests/Golden/Parser/G13/P1.expected.txt view
@@ -0,0 +1,1 @@+[Increment,Increment,Increment,Increment,Increment,Increment,Increment,Increment,Increment,Increment,Loop [Forward,Increment,Increment,Increment,Increment,Increment,Increment,Increment,Forward,Increment,Increment,Increment,Increment,Increment,Increment,Increment,Increment,Increment,Increment,Forward,Increment,Increment,Increment,Forward,Increment,Backward,Backward,Backward,Backward,Decrement],Forward,Increment,Increment,Output,Forward,Increment,Output,Increment,Increment,Increment,Increment,Increment,Increment,Increment,Output,Output,Increment,Increment,Increment,Output,Forward,Increment,Increment,Output,Backward,Backward,Increment,Increment,Increment,Increment,Increment,Increment,Increment,Increment,Increment,Increment,Increment,Increment,Increment,Increment,Increment,Output,Forward,Output,Increment,Increment,Increment,Output,Decrement,Decrement,Decrement,Decrement,Decrement,Decrement,Output,Decrement,Decrement,Decrement,Decrement,Decrement,Decrement,Decrement,Decrement,Output,Forward,Increment,Output,Forward,Output]
+ tests/Golden/Parser/G13/P1.input.txt view
@@ -0,0 +1,1 @@+++++++++++[>+++++++>++++++++++>+++>+<<<<-]>++.>+.+++++++..+++.>++.<<+++++++++++++++.>.+++.------.--------.>+.>.
+ tests/Golden/Parser/G13/P2.expected.txt view
@@ -0,0 +1,1 @@+[Loop [Decrement]]
+ tests/Golden/Parser/G13/P2.input.txt view
@@ -0,0 +1,3 @@+[     boucle+-     enlever 1 à la case courante+]     jusqu'à ce que la case soit à zéro
+ tests/Golden/Parser/G17/P1.expected.txt view
@@ -0,0 +1,1 @@+('a','a')
+ tests/Golden/Parser/G17/P1.input.txt view
@@ -0,0 +1,1 @@+a
+ tests/Golden/Parser/G18/P1.expected.txt view
@@ -0,0 +1,1 @@+"abc"
+ tests/Golden/Parser/G18/P1.input.txt view
@@ -0,0 +1,1 @@+abc
+ tests/Golden/Parser/G18/P2.expected.txt view
@@ -0,0 +1,1 @@+"de"
+ tests/Golden/Parser/G18/P2.input.txt view
@@ -0,0 +1,1 @@+de
+ tests/Golden/Parser/G18/P3.expected.txt view
@@ -0,0 +1,1 @@+ParsingErrorStandard {parsingErrorOffset = 0, parsingErrorException = ExceptionFailure, parsingErrorUnexpected = Just 'a', parsingErrorExpecting = fromList [FailureHorizon 2]}
+ tests/Golden/Parser/G18/P3.input.txt view
@@ -0,0 +1,1 @@+a
+ tests/Golden/Parser/G18/P4.expected.txt view
@@ -0,0 +1,1 @@+ParsingErrorStandard {parsingErrorOffset = 2, parsingErrorException = ExceptionFailure, parsingErrorUnexpected = Nothing, parsingErrorExpecting = fromList [FailureHorizon 1]}
+ tests/Golden/Parser/G18/P4.input.txt view
@@ -0,0 +1,1 @@+ab
+ tests/Golden/Parser/G18/P5.expected.txt view
@@ -0,0 +1,1 @@+ParsingErrorStandard {parsingErrorOffset = 2, parsingErrorException = ExceptionFailure, parsingErrorUnexpected = Just 'C', parsingErrorExpecting = fromList [FailureToken 'c']}
+ tests/Golden/Parser/G18/P5.input.txt view
@@ -0,0 +1,1 @@+abC
+ tests/Golden/Parser/G19/P1.expected.txt view
@@ -0,0 +1,1 @@+ParsingErrorStandard {parsingErrorOffset = 0, parsingErrorException = ExceptionFailure, parsingErrorUnexpected = Nothing, parsingErrorExpecting = fromList [FailureHorizon 2]}
+ tests/Golden/Parser/G19/P1.input.txt view
+ tests/Golden/Parser/G19/P2.expected.txt view
@@ -0,0 +1,1 @@+ParsingErrorStandard {parsingErrorOffset = 0, parsingErrorException = ExceptionFailure, parsingErrorUnexpected = Just 'a', parsingErrorExpecting = fromList [FailureHorizon 2]}
+ tests/Golden/Parser/G19/P2.input.txt view
@@ -0,0 +1,1 @@+a
+ tests/Golden/Parser/G19/P3.expected.txt view
@@ -0,0 +1,1 @@+ParsingErrorStandard {parsingErrorOffset = 2, parsingErrorException = ExceptionFailure, parsingErrorUnexpected = Nothing, parsingErrorExpecting = fromList [FailureHorizon 1]}
+ tests/Golden/Parser/G19/P3.input.txt view
@@ -0,0 +1,1 @@+ab
+ tests/Golden/Parser/G19/P4.expected.txt view
@@ -0,0 +1,1 @@+"abc"
+ tests/Golden/Parser/G19/P4.input.txt view
@@ -0,0 +1,1 @@+abc
+ tests/Golden/Parser/G19/P5.expected.txt view
@@ -0,0 +1,1 @@+ParsingErrorStandard {parsingErrorOffset = 2, parsingErrorException = ExceptionFailure, parsingErrorUnexpected = Just 'C', parsingErrorExpecting = fromList [FailureToken 'c']}
+ tests/Golden/Parser/G19/P5.input.txt view
@@ -0,0 +1,1 @@+abC
+ tests/Golden/Parser/G19/P6.expected.txt view
@@ -0,0 +1,1 @@+ParsingErrorStandard {parsingErrorOffset = 2, parsingErrorException = ExceptionFailure, parsingErrorUnexpected = Just 'd', parsingErrorExpecting = fromList [FailureToken 'c']}
+ tests/Golden/Parser/G19/P6.input.txt view
@@ -0,0 +1,1 @@+abde
+ tests/Golden/Parser/G19/P7.expected.txt view
@@ -0,0 +1,1 @@+ParsingErrorStandard {parsingErrorOffset = 0, parsingErrorException = ExceptionFailure, parsingErrorUnexpected = Just 'd', parsingErrorExpecting = fromList [FailureHorizon 2]}
+ tests/Golden/Parser/G19/P7.input.txt view
@@ -0,0 +1,1 @@+d
+ tests/Golden/Parser/G19/P8.expected.txt view
@@ -0,0 +1,1 @@+"de"
+ tests/Golden/Parser/G19/P8.input.txt view
@@ -0,0 +1,1 @@+de
+ tests/Golden/Parser/G19/P9.expected.txt view
@@ -0,0 +1,1 @@+ParsingErrorStandard {parsingErrorOffset = 2, parsingErrorException = ExceptionFailure, parsingErrorUnexpected = Just 'f', parsingErrorExpecting = fromList [FailureToken 'c']}
+ tests/Golden/Parser/G19/P9.input.txt view
@@ -0,0 +1,1 @@+abfg
+ tests/Golden/Parser/G2/P1.expected.txt view
@@ -0,0 +1,1 @@+"abc"
+ tests/Golden/Parser/G2/P1.input.txt view
@@ -0,0 +1,1 @@+abc
+ tests/Golden/Parser/G2/P2.expected.txt view
@@ -0,0 +1,1 @@+ParsingErrorStandard {parsingErrorOffset = 0, parsingErrorException = ExceptionFailure, parsingErrorUnexpected = Just 'a', parsingErrorExpecting = fromList [FailureHorizon 3]}
+ tests/Golden/Parser/G2/P2.input.txt view
@@ -0,0 +1,1 @@+ab
+ tests/Golden/Parser/G20/P1.expected.txt view
@@ -0,0 +1,1 @@+ParsingErrorStandard {parsingErrorOffset = 0, parsingErrorException = ExceptionFailure, parsingErrorUnexpected = Just '1', parsingErrorExpecting = fromList []}
+ tests/Golden/Parser/G20/P1.input.txt view
@@ -0,0 +1,1 @@+123ab
+ tests/Golden/Parser/G20/P2.expected.txt view
@@ -0,0 +1,1 @@+ParsingErrorStandard {parsingErrorOffset = 3, parsingErrorException = ExceptionFailure, parsingErrorUnexpected = Nothing, parsingErrorExpecting = fromList [FailureHorizon 3]}
+ tests/Golden/Parser/G20/P2.input.txt view
@@ -0,0 +1,1 @@+abc
+ tests/Golden/Parser/G20/P3.expected.txt view
@@ -0,0 +1,1 @@+ParsingErrorStandard {parsingErrorOffset = 0, parsingErrorException = ExceptionFailure, parsingErrorUnexpected = Just '1', parsingErrorExpecting = fromList []}
+ tests/Golden/Parser/G20/P3.input.txt view
@@ -0,0 +1,1 @@+123abc
+ tests/Golden/Parser/G3/P1.expected.txt view
@@ -0,0 +1,1 @@+"aaaaa"
+ tests/Golden/Parser/G3/P1.input.txt view
@@ -0,0 +1,1 @@+aaaaa
+ tests/Golden/Parser/G4/P1.expected.txt view
@@ -0,0 +1,1 @@+["abcd","abcd","abcd"]
+ tests/Golden/Parser/G4/P1.input.txt view
@@ -0,0 +1,1 @@+abcdabcdabcd
+ tests/Golden/Parser/G4/P2.expected.txt view
@@ -0,0 +1,1 @@+["abcd","abcd","abcd"]
+ tests/Golden/Parser/G4/P2.input.txt view
@@ -0,0 +1,1 @@+abcdabcdabcde
+ tests/Golden/Parser/G4/P3.expected.txt view
@@ -0,0 +1,1 @@+["abcd","abcd","abcd"]
+ tests/Golden/Parser/G4/P3.input.txt view
@@ -0,0 +1,1 @@+abcdabcdabcdefgh
+ tests/Golden/Parser/G5/P1.expected.txt view
@@ -0,0 +1,1 @@+ParsingErrorStandard {parsingErrorOffset = 0, parsingErrorException = ExceptionFailure, parsingErrorUnexpected = Just 'a', parsingErrorExpecting = fromList [FailureHorizon 4]}
+ tests/Golden/Parser/G5/P1.input.txt view
@@ -0,0 +1,1 @@+abc
+ tests/Golden/Parser/G5/P2.expected.txt view
@@ -0,0 +1,1 @@+ParsingErrorStandard {parsingErrorOffset = 4, parsingErrorException = ExceptionFailure, parsingErrorUnexpected = Just 'a', parsingErrorExpecting = fromList [FailureEnd,FailureHorizon 4]}
+ tests/Golden/Parser/G5/P2.input.txt view
@@ -0,0 +1,1 @@+abcdabc
+ tests/Golden/Parser/G5/P3.expected.txt view
@@ -0,0 +1,1 @@+ParsingErrorStandard {parsingErrorOffset = 4, parsingErrorException = ExceptionFailure, parsingErrorUnexpected = Just 'e', parsingErrorExpecting = fromList [FailureEnd,FailureToken 'a']}
+ tests/Golden/Parser/G5/P3.input.txt view
@@ -0,0 +1,1 @@+abcdefgh
+ tests/Golden/Parser/G6/P1.expected.txt view
@@ -0,0 +1,1 @@+ParsingErrorStandard {parsingErrorOffset = 1, parsingErrorException = ExceptionFailure, parsingErrorUnexpected = Just 'b', parsingErrorExpecting = fromList [FailureToken 'a']}
+ tests/Golden/Parser/G6/P1.input.txt view
@@ -0,0 +1,1 @@+ab
+ tests/Golden/Parser/G7/P1.expected.txt view
@@ -0,0 +1,1 @@+"ab"
+ tests/Golden/Parser/G7/P1.input.txt view
@@ -0,0 +1,1 @@+ab
+ tests/Golden/Parser/G7/P2.expected.txt view
@@ -0,0 +1,1 @@+"aa"
+ tests/Golden/Parser/G7/P2.input.txt view
@@ -0,0 +1,1 @@+aa
+ tests/Golden/Parser/G8/P1.expected.txt view
@@ -0,0 +1,1 @@+ParsingErrorStandard {parsingErrorOffset = 3, parsingErrorException = ExceptionFailure, parsingErrorUnexpected = Just 'a', parsingErrorExpecting = fromList [FailureEnd,FailureToken 'r']}
+ tests/Golden/Parser/G8/P1.input.txt view
@@ -0,0 +1,1 @@+rrra
+ tests/Golden/Parser/G9/P1.expected.txt view
@@ -0,0 +1,1 @@+()
+ tests/Golden/Parser/G9/P1.input.txt view
+ tests/Golden/Parser/G9/P2.expected.txt view
@@ -0,0 +1,1 @@+ParsingErrorStandard {parsingErrorOffset = 0, parsingErrorException = ExceptionFailure, parsingErrorUnexpected = Just 'a', parsingErrorExpecting = fromList [FailureEnd]}
+ tests/Golden/Parser/G9/P2.input.txt view
@@ -0,0 +1,1 @@+a
+ tests/Golden/Parser/left-right.txt view
@@ -0,0 +1,1 @@+aa
+ tests/Golden/Splice.hs view
@@ -0,0 +1,52 @@+{-# OPTIONS_GHC -Wno-missing-signatures #-}+{-# OPTIONS_GHC -Wno-incomplete-uni-patterns #-}+module Golden.Splice where++import Data.Either (Either(..))+import Data.Function (($))+import Data.Functor ((<$>))+import Data.Int (Int)+import Data.List ((++))+import Data.String (String, IsString(..))+import Data.Text (Text)+import Symantic.Parser (ParsingError, optimizeMachine, generateCode)+import System.FilePath (dropExtensions, takeBaseName, (</>), (<.>))+import System.IO (IO)+import Test.Tasty+import Test.Tasty.Golden (goldenVsStringDiff)+import Text.Show (Show(..))+import qualified Data.List as List+import qualified Language.Haskell.TH as TH+import qualified Language.Haskell.TH.HideName as TH+import qualified System.Process as Process++import Golden.Utils+import qualified Grammar+import Symantic.Parser.Grammar (optimizeGrammar)++goldens :: TestTree+goldens = testGroup "Splice"+  [ let spliceFile = getGoldenDir $ "Splice/"</>"G"++show gNum<.>"expected"<.>"txt" in+    goldenVsStringDiff (takeBaseName (dropExtensions spliceFile)) goldenDiff spliceFile $ do+      tExp <- splice+      fromString <$> Process.readProcess "ormolu"+        [ "-o", "-XBangPatterns"+        , "-o", "-XMagicHash"+        , "-o", "-XTypeApplications"+        , "-o", "-XUnboxedTuples"+        ]+        (show (TH.ppr (TH.hideName (TH.unType tExp))))+  | (gNum, splice) <- List.zip [1::Int ..] splices+  ]++splices :: [IO (TH.TExp (Text -> Either (ParsingError Text) String))]+splices = (<$> Grammar.grammars) $ \g -> TH.runQ $ do+  mach <- TH.runIO $ do+    resetTHNameCounter+    optimizeMachine $ optimizeGrammar g+  TH.examineCode $ generateCode mach++[ s1,s2,s3,s4,s5,s6,s7,s8,s9+ ,s10,s11,s12,s13,s14,s15,s16,s17,s18,s19+ ,s20+ ] = splices
+ tests/Golden/Splice/G1.expected.txt view
@@ -0,0 +1,177 @@+\(input :: inp) ->+  let !(#+         init,+         readMore,+         readNext+         #) =+          let _ = "cursorOf"+           in let next+                    ( t@( Data.Text.Internal.Text+                            arr+                            off+                            unconsumed+                          )+                      ) =+                      let !( Data.Text.Unsafe.Iter+                               c+                               d+                             ) = Data.Text.Unsafe.iter t 0+                       in (#+                            c,+                            Data.Text.Internal.Text arr (off GHC.Num.+ d) (unconsumed GHC.Num.- d)+                          #)+                  more+                    ( Data.Text.Internal.Text+                        _+                        _+                        unconsumed+                      ) = unconsumed GHC.Classes.> 0+               in (# input, more, next #)+      finalRet = \_farInp _farExp v _inp -> Symantic.Parser.Machine.Generate.returnST GHC.Base.$ Data.Either.Right v+      finalRaise ::+        forall st b.+        Symantic.Parser.Machine.Generate.OnException+          st+          inp+          b = \(!exn) _failInp (!farInp) (!farExp) ->+          Symantic.Parser.Machine.Generate.returnST GHC.Base.$+            Data.Either.Left+              Symantic.Parser.Machine.Generate.ParsingError+                { Symantic.Parser.Machine.Generate.parsingErrorOffset = Symantic.Parser.Machine.Input.offset farInp,+                  Symantic.Parser.Machine.Generate.parsingErrorException = exn,+                  Symantic.Parser.Machine.Generate.parsingErrorUnexpected =+                    if readMore farInp+                      then+                        GHC.Maybe.Just+                          ( let (#+                                  c,+                                  _+                                  #) = readNext farInp+                             in c+                          )+                      else GHC.Maybe.Nothing,+                  Symantic.Parser.Machine.Generate.parsingErrorExpecting =+                    let ( minHoriz,+                          res+                          ) =+                            Data.Set.Internal.foldr+                              ( \f+                                 ( minH,+                                   acc+                                   ) -> case Symantic.Parser.Grammar.Combinators.unSomeFailure f of+                                    GHC.Maybe.Just (Symantic.Parser.Grammar.Combinators.FailureHorizon h :: Symantic.Parser.Grammar.Combinators.Failure (Symantic.Parser.Grammar.Combinators.CombSatisfiable (Symantic.Parser.Machine.Input.InputToken inp)))+                                      | GHC.Maybe.Just old <- minH ->+                                        ( GHC.Maybe.Just (GHC.Classes.min old h),+                                          acc+                                        )+                                      | GHC.Base.otherwise ->+                                        ( GHC.Maybe.Just h,+                                          acc+                                        )+                                    _ ->+                                      ( minH,+                                        f GHC.Types.: acc+                                      )+                              )+                              ( GHC.Maybe.Nothing,+                                GHC.Types . []+                              )+                              farExp+                     in Data.Set.Internal.fromList GHC.Base.$+                          ( case minHoriz of+                              GHC.Maybe.Just h -> Symantic.Parser.Grammar.Combinators.SomeFailure (Symantic.Parser.Grammar.Combinators.FailureHorizon @(Symantic.Parser.Machine.Input.InputToken inp) h) GHC.Types.: res+                              GHC.Maybe.Nothing -> res+                          )+                }+   in GHC.ST.runST+        ( let inputToken = Data.Proxy.Proxy :: Data.Proxy.Proxy (Symantic.Parser.Machine.Input.InputToken inp)+           in let inp = init+               in let readFail = finalRaise+                   in let _ = "checkHorizon.newCheck: checkedHorizon=0 minHoriz=1"+                       in if readMore inp+                            then+                              let+                               in let _ = "pushValue"+                                   in let _ = "comment: satisfy ((GHC.Classes.==) 'a')"+                                       in let _ = "checkHorizon.oldCheck: checkedHorizon=1"+                                           in let _ = "checkToken"+                                               in let !(#+                                                         c,+                                                         cs+                                                         #) = readNext inp+                                                   in if (GHC.Classes.==) 'a' c+                                                        then+                                                          let _ = "lift2Value checkedHorizon=0"+                                                           in let _ = "resume"+                                                               in finalRet+                                                                    init+                                                                    Data.Set.Internal.empty+                                                                    ( let _ = "resume.genCode"+                                                                       in GHC.Show.show 'a'+                                                                    )+                                                                    cs+                                                        else+                                                          let _ = "checkToken.fail"+                                                           in let failExp =+                                                                    Data.Set.Internal.Bin+                                                                      1+                                                                      ( Symantic.Parser.Grammar.Combinators.SomeFailure+                                                                          ( case inputToken of+                                                                              (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken 'a'+                                                                          )+                                                                      )+                                                                      Data.Set.Internal.Tip+                                                                      Data.Set.Internal.Tip+                                                               in let (#+                                                                        farInp,+                                                                        farExp+                                                                        #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init inp of+                                                                          GHC.Types.LT ->+                                                                            (#+                                                                              inp,+                                                                              failExp+                                                                            #)+                                                                          GHC.Types.EQ ->+                                                                            (#+                                                                              init,+                                                                              failExp GHC.Base.<> Data.Set.Internal.empty+                                                                            #)+                                                                          GHC.Types.GT ->+                                                                            (#+                                                                              init,+                                                                              Data.Set.Internal.empty+                                                                            #)+                                                                   in finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp+                            else+                              let _ = "checkHorizon.newCheck.fail"+                               in let failExp =+                                        Data.Set.Internal.Bin+                                          1+                                          ( Symantic.Parser.Grammar.Combinators.SomeFailure+                                              ( case inputToken of+                                                  (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureHorizon @tok' 1+                                              )+                                          )+                                          Data.Set.Internal.Tip+                                          Data.Set.Internal.Tip+                                   in let (#+                                            farInp,+                                            farExp+                                            #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init inp of+                                              GHC.Types.LT ->+                                                (#+                                                  inp,+                                                  failExp+                                                #)+                                              GHC.Types.EQ ->+                                                (#+                                                  init,+                                                  failExp GHC.Base.<> Data.Set.Internal.empty+                                                #)+                                              GHC.Types.GT ->+                                                (#+                                                  init,+                                                  Data.Set.Internal.empty+                                                #)+                                       in finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp+        )
+ tests/Golden/Splice/G10.expected.txt view
@@ -0,0 +1,301 @@+\(input :: inp) ->+  let !(#+         init,+         readMore,+         readNext+         #) =+          let _ = "cursorOf"+           in let next+                    ( t@( Data.Text.Internal.Text+                            arr+                            off+                            unconsumed+                          )+                      ) =+                      let !( Data.Text.Unsafe.Iter+                               c+                               d+                             ) = Data.Text.Unsafe.iter t 0+                       in (#+                            c,+                            Data.Text.Internal.Text arr (off GHC.Num.+ d) (unconsumed GHC.Num.- d)+                          #)+                  more+                    ( Data.Text.Internal.Text+                        _+                        _+                        unconsumed+                      ) = unconsumed GHC.Classes.> 0+               in (# input, more, next #)+      finalRet = \_farInp _farExp v _inp -> Symantic.Parser.Machine.Generate.returnST GHC.Base.$ Data.Either.Right v+      finalRaise ::+        forall st b.+        Symantic.Parser.Machine.Generate.OnException+          st+          inp+          b = \(!exn) _failInp (!farInp) (!farExp) ->+          Symantic.Parser.Machine.Generate.returnST GHC.Base.$+            Data.Either.Left+              Symantic.Parser.Machine.Generate.ParsingError+                { Symantic.Parser.Machine.Generate.parsingErrorOffset = Symantic.Parser.Machine.Input.offset farInp,+                  Symantic.Parser.Machine.Generate.parsingErrorException = exn,+                  Symantic.Parser.Machine.Generate.parsingErrorUnexpected =+                    if readMore farInp+                      then+                        GHC.Maybe.Just+                          ( let (#+                                  c,+                                  _+                                  #) = readNext farInp+                             in c+                          )+                      else GHC.Maybe.Nothing,+                  Symantic.Parser.Machine.Generate.parsingErrorExpecting =+                    let ( minHoriz,+                          res+                          ) =+                            Data.Set.Internal.foldr+                              ( \f+                                 ( minH,+                                   acc+                                   ) -> case Symantic.Parser.Grammar.Combinators.unSomeFailure f of+                                    GHC.Maybe.Just (Symantic.Parser.Grammar.Combinators.FailureHorizon h :: Symantic.Parser.Grammar.Combinators.Failure (Symantic.Parser.Grammar.Combinators.CombSatisfiable (Symantic.Parser.Machine.Input.InputToken inp)))+                                      | GHC.Maybe.Just old <- minH ->+                                        ( GHC.Maybe.Just (GHC.Classes.min old h),+                                          acc+                                        )+                                      | GHC.Base.otherwise ->+                                        ( GHC.Maybe.Just h,+                                          acc+                                        )+                                    _ ->+                                      ( minH,+                                        f GHC.Types.: acc+                                      )+                              )+                              ( GHC.Maybe.Nothing,+                                GHC.Types . []+                              )+                              farExp+                     in Data.Set.Internal.fromList GHC.Base.$+                          ( case minHoriz of+                              GHC.Maybe.Just h -> Symantic.Parser.Grammar.Combinators.SomeFailure (Symantic.Parser.Grammar.Combinators.FailureHorizon @(Symantic.Parser.Machine.Input.InputToken inp) h) GHC.Types.: res+                              GHC.Maybe.Nothing -> res+                          )+                }+   in GHC.ST.runST+        ( let inputToken = Data.Proxy.Proxy :: Data.Proxy.Proxy (Symantic.Parser.Machine.Input.InputToken inp)+           in let inp = init+               in let readFail = finalRaise+                   in let _ = "checkHorizon.newCheck: checkedHorizon=0 minHoriz=1"+                       in if readMore inp+                            then+                              let+                               in let _ = "pushValue"+                                   in let join = \farInp farExp v (!inp) ->+                                            let _ = "lift2Value checkedHorizon=0"+                                             in let _ = "resume"+                                                 in finalRet+                                                      farInp+                                                      farExp+                                                      ( let _ = "resume.genCode"+                                                         in GHC.Show.show v+                                                      )+                                                      inp+                                       in let _ = "catch ExceptionFailure checkedHorizon=1"+                                           in let onException =+                                                    let _ = "onException"+                                                     in \(!_exn) (!failInp) (!farInp) (!farExp) ->+                                                          let _ = "comment: raiseAgainIfConsumed"+                                                           in let _ = "saveInput checkedHorizon=0"+                                                               in let _ = "lift2Value checkedHorizon=0"+                                                                   in if ( \( Data.Text.Internal.Text+                                                                                _+                                                                                i+                                                                                _+                                                                              )+                                                                            ( Data.Text.Internal.Text+                                                                                _+                                                                                j+                                                                                _+                                                                              ) -> i GHC.Classes.== j+                                                                         )+                                                                        inp+                                                                        failInp+                                                                        then+                                                                          let _ = "choicesBranch checkedHorizon=0"+                                                                           in let _ = "pushValue"+                                                                               in let _ = "comment: satisfy ((GHC.Classes.==) 'b')"+                                                                                   in let inp = failInp+                                                                                       in let readFail = finalRaise+                                                                                           in let _ = "checkHorizon.newCheck: checkedHorizon=0 minHoriz=1"+                                                                                               in if readMore inp+                                                                                                    then+                                                                                                      let _ = "checkToken"+                                                                                                       in let !(#+                                                                                                                 c,+                                                                                                                 cs+                                                                                                                 #) = readNext inp+                                                                                                           in if (GHC.Classes.==) 'b' c+                                                                                                                then+                                                                                                                  let _ = "lift2Value checkedHorizon=1"+                                                                                                                   in let _ = "resume"+                                                                                                                       in join+                                                                                                                            farInp+                                                                                                                            farExp+                                                                                                                            ( let _ = "resume.genCode"+                                                                                                                               in 'b'+                                                                                                                            )+                                                                                                                            cs+                                                                                                                else+                                                                                                                  let _ = "checkToken.fail"+                                                                                                                   in let failExp =+                                                                                                                            Data.Set.Internal.Bin+                                                                                                                              1+                                                                                                                              ( Symantic.Parser.Grammar.Combinators.SomeFailure+                                                                                                                                  ( case inputToken of+                                                                                                                                      (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken 'b'+                                                                                                                                  )+                                                                                                                              )+                                                                                                                              Data.Set.Internal.Tip+                                                                                                                              Data.Set.Internal.Tip+                                                                                                                       in let (#+                                                                                                                                farInp,+                                                                                                                                farExp+                                                                                                                                #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp inp of+                                                                                                                                  GHC.Types.LT ->+                                                                                                                                    (#+                                                                                                                                      inp,+                                                                                                                                      failExp+                                                                                                                                    #)+                                                                                                                                  GHC.Types.EQ ->+                                                                                                                                    (#+                                                                                                                                      farInp,+                                                                                                                                      failExp GHC.Base.<> farExp+                                                                                                                                    #)+                                                                                                                                  GHC.Types.GT ->+                                                                                                                                    (#+                                                                                                                                      farInp,+                                                                                                                                      farExp+                                                                                                                                    #)+                                                                                                                           in finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp+                                                                                                    else+                                                                                                      let _ = "checkHorizon.newCheck.fail"+                                                                                                       in let failExp =+                                                                                                                Data.Set.Internal.Bin+                                                                                                                  1+                                                                                                                  ( Symantic.Parser.Grammar.Combinators.SomeFailure+                                                                                                                      ( case inputToken of+                                                                                                                          (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureHorizon @tok' 1+                                                                                                                      )+                                                                                                                  )+                                                                                                                  Data.Set.Internal.Tip+                                                                                                                  Data.Set.Internal.Tip+                                                                                                           in let (#+                                                                                                                    farInp,+                                                                                                                    farExp+                                                                                                                    #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp inp of+                                                                                                                      GHC.Types.LT ->+                                                                                                                        (#+                                                                                                                          inp,+                                                                                                                          failExp+                                                                                                                        #)+                                                                                                                      GHC.Types.EQ ->+                                                                                                                        (#+                                                                                                                          farInp,+                                                                                                                          failExp GHC.Base.<> farExp+                                                                                                                        #)+                                                                                                                      GHC.Types.GT ->+                                                                                                                        (#+                                                                                                                          farInp,+                                                                                                                          farExp+                                                                                                                        #)+                                                                                                               in finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp+                                                                        else+                                                                          let _ = "choicesBranch.else"+                                                                           in finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp farInp farExp+                                               in let _ = "pushValue"+                                                   in let _ = "comment: satisfy ((GHC.Classes.==) 'a')"+                                                       in let _ = "checkHorizon.oldCheck: checkedHorizon=1"+                                                           in let _ = "checkToken"+                                                               in let !(#+                                                                         c,+                                                                         cs+                                                                         #) = readNext inp+                                                                   in if (GHC.Classes.==) 'a' c+                                                                        then+                                                                          let _ = "lift2Value checkedHorizon=0"+                                                                           in let _ = "commit"+                                                                               in let _ = "resume"+                                                                                   in join+                                                                                        init+                                                                                        Data.Set.Internal.empty+                                                                                        ( let _ = "resume.genCode"+                                                                                           in 'a'+                                                                                        )+                                                                                        cs+                                                                        else+                                                                          let _ = "checkToken.fail"+                                                                           in let failExp =+                                                                                    Data.Set.Internal.Bin+                                                                                      1+                                                                                      ( Symantic.Parser.Grammar.Combinators.SomeFailure+                                                                                          ( case inputToken of+                                                                                              (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken 'a'+                                                                                          )+                                                                                      )+                                                                                      Data.Set.Internal.Tip+                                                                                      Data.Set.Internal.Tip+                                                                               in let (#+                                                                                        farInp,+                                                                                        farExp+                                                                                        #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init inp of+                                                                                          GHC.Types.LT ->+                                                                                            (#+                                                                                              inp,+                                                                                              failExp+                                                                                            #)+                                                                                          GHC.Types.EQ ->+                                                                                            (#+                                                                                              init,+                                                                                              failExp GHC.Base.<> Data.Set.Internal.empty+                                                                                            #)+                                                                                          GHC.Types.GT ->+                                                                                            (#+                                                                                              init,+                                                                                              Data.Set.Internal.empty+                                                                                            #)+                                                                                   in onException Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp+                            else+                              let _ = "checkHorizon.newCheck.fail"+                               in let failExp =+                                        Data.Set.Internal.Bin+                                          1+                                          ( Symantic.Parser.Grammar.Combinators.SomeFailure+                                              ( case inputToken of+                                                  (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureHorizon @tok' 1+                                              )+                                          )+                                          Data.Set.Internal.Tip+                                          Data.Set.Internal.Tip+                                   in let (#+                                            farInp,+                                            farExp+                                            #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init inp of+                                              GHC.Types.LT ->+                                                (#+                                                  inp,+                                                  failExp+                                                #)+                                              GHC.Types.EQ ->+                                                (#+                                                  init,+                                                  failExp GHC.Base.<> Data.Set.Internal.empty+                                                #)+                                              GHC.Types.GT ->+                                                (#+                                                  init,+                                                  Data.Set.Internal.empty+                                                #)+                                       in finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp+        )
+ tests/Golden/Splice/G11.expected.txt view
@@ -0,0 +1,339 @@+\(input :: inp) ->+  let !(#+         init,+         readMore,+         readNext+         #) =+          let _ = "cursorOf"+           in let next+                    ( t@( Data.Text.Internal.Text+                            arr+                            off+                            unconsumed+                          )+                      ) =+                      let !( Data.Text.Unsafe.Iter+                               c+                               d+                             ) = Data.Text.Unsafe.iter t 0+                       in (#+                            c,+                            Data.Text.Internal.Text arr (off GHC.Num.+ d) (unconsumed GHC.Num.- d)+                          #)+                  more+                    ( Data.Text.Internal.Text+                        _+                        _+                        unconsumed+                      ) = unconsumed GHC.Classes.> 0+               in (# input, more, next #)+      finalRet = \_farInp _farExp v _inp -> Symantic.Parser.Machine.Generate.returnST GHC.Base.$ Data.Either.Right v+      finalRaise ::+        forall st b.+        Symantic.Parser.Machine.Generate.OnException+          st+          inp+          b = \(!exn) _failInp (!farInp) (!farExp) ->+          Symantic.Parser.Machine.Generate.returnST GHC.Base.$+            Data.Either.Left+              Symantic.Parser.Machine.Generate.ParsingError+                { Symantic.Parser.Machine.Generate.parsingErrorOffset = Symantic.Parser.Machine.Input.offset farInp,+                  Symantic.Parser.Machine.Generate.parsingErrorException = exn,+                  Symantic.Parser.Machine.Generate.parsingErrorUnexpected =+                    if readMore farInp+                      then+                        GHC.Maybe.Just+                          ( let (#+                                  c,+                                  _+                                  #) = readNext farInp+                             in c+                          )+                      else GHC.Maybe.Nothing,+                  Symantic.Parser.Machine.Generate.parsingErrorExpecting =+                    let ( minHoriz,+                          res+                          ) =+                            Data.Set.Internal.foldr+                              ( \f+                                 ( minH,+                                   acc+                                   ) -> case Symantic.Parser.Grammar.Combinators.unSomeFailure f of+                                    GHC.Maybe.Just (Symantic.Parser.Grammar.Combinators.FailureHorizon h :: Symantic.Parser.Grammar.Combinators.Failure (Symantic.Parser.Grammar.Combinators.CombSatisfiable (Symantic.Parser.Machine.Input.InputToken inp)))+                                      | GHC.Maybe.Just old <- minH ->+                                        ( GHC.Maybe.Just (GHC.Classes.min old h),+                                          acc+                                        )+                                      | GHC.Base.otherwise ->+                                        ( GHC.Maybe.Just h,+                                          acc+                                        )+                                    _ ->+                                      ( minH,+                                        f GHC.Types.: acc+                                      )+                              )+                              ( GHC.Maybe.Nothing,+                                GHC.Types . []+                              )+                              farExp+                     in Data.Set.Internal.fromList GHC.Base.$+                          ( case minHoriz of+                              GHC.Maybe.Just h -> Symantic.Parser.Grammar.Combinators.SomeFailure (Symantic.Parser.Grammar.Combinators.FailureHorizon @(Symantic.Parser.Machine.Input.InputToken inp) h) GHC.Types.: res+                              GHC.Maybe.Nothing -> res+                          )+                }+   in GHC.ST.runST+        ( let inputToken = Data.Proxy.Proxy :: Data.Proxy.Proxy (Symantic.Parser.Machine.Input.InputToken inp)+           in let inp = init+               in let readFail = finalRaise+                   in let _ = "checkHorizon.newCheck: checkedHorizon=0 minHoriz=1"+                       in if readMore inp+                            then+                              let+                               in let _ = "pushValue"+                                   in let _ = "pushValue"+                                       in do+                                            let dupv = \x -> x+                                            reg <- GHC.STRef.newSTRef dupv+                                            let _ = "iter"+                                             in let onException loopInput =+                                                      let _ = "onException"+                                                       in \(!_exn) (!failInp) (!farInp) (!farExp) ->+                                                            let _ = "comment: raiseAgainIfConsumed"+                                                             in let _ = "saveInput checkedHorizon=0"+                                                                 in let _ = "lift2Value checkedHorizon=0"+                                                                     in if ( \( Data.Text.Internal.Text+                                                                                  _+                                                                                  i+                                                                                  _+                                                                                )+                                                                              ( Data.Text.Internal.Text+                                                                                  _+                                                                                  j+                                                                                  _+                                                                                ) -> i GHC.Classes.== j+                                                                           )+                                                                          loopInput+                                                                          failInp+                                                                          then+                                                                            let _ = "choicesBranch checkedHorizon=0"+                                                                             in do+                                                                                  sr <- GHC.STRef.readSTRef reg+                                                                                  let _ = "pushValue"+                                                                                   in let _ = "lift2Value checkedHorizon=0"+                                                                                       in let _ = "lift2Value checkedHorizon=0"+                                                                                           in let _ = "comment: satisfy ((GHC.Classes.==) 'b')"+                                                                                               in let inp = failInp+                                                                                                   in let readFail = finalRaise+                                                                                                       in let _ = "checkHorizon.newCheck: checkedHorizon=0 minHoriz=1"+                                                                                                           in if readMore inp+                                                                                                                then+                                                                                                                  let _ = "checkToken"+                                                                                                                   in let !(#+                                                                                                                             c,+                                                                                                                             cs+                                                                                                                             #) = readNext inp+                                                                                                                       in if (GHC.Classes.==) 'b' c+                                                                                                                            then+                                                                                                                              let _ = "lift2Value checkedHorizon=1"+                                                                                                                               in let _ = "resume"+                                                                                                                                   in finalRet+                                                                                                                                        farInp+                                                                                                                                        farExp+                                                                                                                                        ( let _ = "resume.genCode"+                                                                                                                                           in GHC.Show.show (sr GHC.Types . [])+                                                                                                                                        )+                                                                                                                                        cs+                                                                                                                            else+                                                                                                                              let _ = "checkToken.fail"+                                                                                                                               in let failExp =+                                                                                                                                        Data.Set.Internal.Bin+                                                                                                                                          1+                                                                                                                                          ( Symantic.Parser.Grammar.Combinators.SomeFailure+                                                                                                                                              ( case inputToken of+                                                                                                                                                  (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken 'b'+                                                                                                                                              )+                                                                                                                                          )+                                                                                                                                          Data.Set.Internal.Tip+                                                                                                                                          Data.Set.Internal.Tip+                                                                                                                                   in let (#+                                                                                                                                            farInp,+                                                                                                                                            farExp+                                                                                                                                            #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp inp of+                                                                                                                                              GHC.Types.LT ->+                                                                                                                                                (#+                                                                                                                                                  inp,+                                                                                                                                                  failExp+                                                                                                                                                #)+                                                                                                                                              GHC.Types.EQ ->+                                                                                                                                                (#+                                                                                                                                                  farInp,+                                                                                                                                                  failExp GHC.Base.<> farExp+                                                                                                                                                #)+                                                                                                                                              GHC.Types.GT ->+                                                                                                                                                (#+                                                                                                                                                  farInp,+                                                                                                                                                  farExp+                                                                                                                                                #)+                                                                                                                                       in finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp+                                                                                                                else+                                                                                                                  let _ = "checkHorizon.newCheck.fail"+                                                                                                                   in let failExp =+                                                                                                                            Data.Set.Internal.Bin+                                                                                                                              1+                                                                                                                              ( Symantic.Parser.Grammar.Combinators.SomeFailure+                                                                                                                                  ( case inputToken of+                                                                                                                                      (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureHorizon @tok' 1+                                                                                                                                  )+                                                                                                                              )+                                                                                                                              Data.Set.Internal.Tip+                                                                                                                              Data.Set.Internal.Tip+                                                                                                                       in let (#+                                                                                                                                farInp,+                                                                                                                                farExp+                                                                                                                                #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp inp of+                                                                                                                                  GHC.Types.LT ->+                                                                                                                                    (#+                                                                                                                                      inp,+                                                                                                                                      failExp+                                                                                                                                    #)+                                                                                                                                  GHC.Types.EQ ->+                                                                                                                                    (#+                                                                                                                                      farInp,+                                                                                                                                      failExp GHC.Base.<> farExp+                                                                                                                                    #)+                                                                                                                                  GHC.Types.GT ->+                                                                                                                                    (#+                                                                                                                                      farInp,+                                                                                                                                      farExp+                                                                                                                                    #)+                                                                                                                           in finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp+                                                                          else+                                                                            let _ = "choicesBranch.else"+                                                                             in finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp farInp farExp+                                                    loop = \_callerOnReturn callerInput callerOnExceptionStackByLabel ->+                                                      let _ = "pushValue"+                                                       in let _ = "comment: satisfy ((GHC.Classes.==) 'a')"+                                                           in let inp = callerInput+                                                               in let readFail = onException callerInput+                                                                   in let _ = "checkHorizon.newCheck: checkedHorizon=0 minHoriz=1"+                                                                       in if readMore inp+                                                                            then+                                                                              let _ = "checkToken"+                                                                               in let !(#+                                                                                         c,+                                                                                         cs+                                                                                         #) = readNext inp+                                                                                   in if (GHC.Classes.==) 'a' c+                                                                                        then+                                                                                          let _ = "lift2Value checkedHorizon=1"+                                                                                           in let _ = "pushValue"+                                                                                               in let _ = "lift2Value checkedHorizon=1"+                                                                                                   in do+                                                                                                        sr <- GHC.STRef.readSTRef reg+                                                                                                        let _ = "lift2Value checkedHorizon=1"+                                                                                                         in do+                                                                                                              let dupv = \x -> sr ((GHC.Types.:) 'a' x)+                                                                                                              GHC.STRef.writeSTRef reg dupv+                                                                                                              let _ = "jump"+                                                                                                               in loop (GHC.Err.error "invalid onReturn") cs (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure readFail Data.Map.Internal.Tip Data.Map.Internal.Tip)+                                                                                        else+                                                                                          let _ = "checkToken.fail"+                                                                                           in let failExp =+                                                                                                    Data.Set.Internal.Bin+                                                                                                      1+                                                                                                      ( Symantic.Parser.Grammar.Combinators.SomeFailure+                                                                                                          ( case inputToken of+                                                                                                              (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken 'a'+                                                                                                          )+                                                                                                      )+                                                                                                      Data.Set.Internal.Tip+                                                                                                      Data.Set.Internal.Tip+                                                                                               in let (#+                                                                                                        farInp,+                                                                                                        farExp+                                                                                                        #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init inp of+                                                                                                          GHC.Types.LT ->+                                                                                                            (#+                                                                                                              inp,+                                                                                                              failExp+                                                                                                            #)+                                                                                                          GHC.Types.EQ ->+                                                                                                            (#+                                                                                                              init,+                                                                                                              failExp GHC.Base.<> Data.Set.Internal.empty+                                                                                                            #)+                                                                                                          GHC.Types.GT ->+                                                                                                            (#+                                                                                                              init,+                                                                                                              Data.Set.Internal.empty+                                                                                                            #)+                                                                                                   in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp+                                                                            else+                                                                              let _ = "checkHorizon.newCheck.fail"+                                                                               in let failExp =+                                                                                        Data.Set.Internal.Bin+                                                                                          1+                                                                                          ( Symantic.Parser.Grammar.Combinators.SomeFailure+                                                                                              ( case inputToken of+                                                                                                  (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureHorizon @tok' 1+                                                                                              )+                                                                                          )+                                                                                          Data.Set.Internal.Tip+                                                                                          Data.Set.Internal.Tip+                                                                                   in let (#+                                                                                            farInp,+                                                                                            farExp+                                                                                            #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init inp of+                                                                                              GHC.Types.LT ->+                                                                                                (#+                                                                                                  inp,+                                                                                                  failExp+                                                                                                #)+                                                                                              GHC.Types.EQ ->+                                                                                                (#+                                                                                                  init,+                                                                                                  failExp GHC.Base.<> Data.Set.Internal.empty+                                                                                                #)+                                                                                              GHC.Types.GT ->+                                                                                                (#+                                                                                                  init,+                                                                                                  Data.Set.Internal.empty+                                                                                                #)+                                                                                       in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp+                                                 in let _ = "jump"+                                                     in loop finalRet inp Data.Map.Internal.Tip+                            else+                              let _ = "checkHorizon.newCheck.fail"+                               in let failExp =+                                        Data.Set.Internal.Bin+                                          1+                                          ( Symantic.Parser.Grammar.Combinators.SomeFailure+                                              ( case inputToken of+                                                  (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureHorizon @tok' 1+                                              )+                                          )+                                          Data.Set.Internal.Tip+                                          Data.Set.Internal.Tip+                                   in let (#+                                            farInp,+                                            farExp+                                            #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init inp of+                                              GHC.Types.LT ->+                                                (#+                                                  inp,+                                                  failExp+                                                #)+                                              GHC.Types.EQ ->+                                                (#+                                                  init,+                                                  failExp GHC.Base.<> Data.Set.Internal.empty+                                                #)+                                              GHC.Types.GT ->+                                                (#+                                                  init,+                                                  Data.Set.Internal.empty+                                                #)+                                       in finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp+        )
+ tests/Golden/Splice/G12.expected.txt view
@@ -0,0 +1,369 @@+\(input :: inp) ->+  let !(#+         init,+         readMore,+         readNext+         #) =+          let _ = "cursorOf"+           in let next+                    ( t@( Data.Text.Internal.Text+                            arr+                            off+                            unconsumed+                          )+                      ) =+                      let !( Data.Text.Unsafe.Iter+                               c+                               d+                             ) = Data.Text.Unsafe.iter t 0+                       in (#+                            c,+                            Data.Text.Internal.Text arr (off GHC.Num.+ d) (unconsumed GHC.Num.- d)+                          #)+                  more+                    ( Data.Text.Internal.Text+                        _+                        _+                        unconsumed+                      ) = unconsumed GHC.Classes.> 0+               in (# input, more, next #)+      finalRet = \_farInp _farExp v _inp -> Symantic.Parser.Machine.Generate.returnST GHC.Base.$ Data.Either.Right v+      finalRaise ::+        forall st b.+        Symantic.Parser.Machine.Generate.OnException+          st+          inp+          b = \(!exn) _failInp (!farInp) (!farExp) ->+          Symantic.Parser.Machine.Generate.returnST GHC.Base.$+            Data.Either.Left+              Symantic.Parser.Machine.Generate.ParsingError+                { Symantic.Parser.Machine.Generate.parsingErrorOffset = Symantic.Parser.Machine.Input.offset farInp,+                  Symantic.Parser.Machine.Generate.parsingErrorException = exn,+                  Symantic.Parser.Machine.Generate.parsingErrorUnexpected =+                    if readMore farInp+                      then+                        GHC.Maybe.Just+                          ( let (#+                                  c,+                                  _+                                  #) = readNext farInp+                             in c+                          )+                      else GHC.Maybe.Nothing,+                  Symantic.Parser.Machine.Generate.parsingErrorExpecting =+                    let ( minHoriz,+                          res+                          ) =+                            Data.Set.Internal.foldr+                              ( \f+                                 ( minH,+                                   acc+                                   ) -> case Symantic.Parser.Grammar.Combinators.unSomeFailure f of+                                    GHC.Maybe.Just (Symantic.Parser.Grammar.Combinators.FailureHorizon h :: Symantic.Parser.Grammar.Combinators.Failure (Symantic.Parser.Grammar.Combinators.CombSatisfiable (Symantic.Parser.Machine.Input.InputToken inp)))+                                      | GHC.Maybe.Just old <- minH ->+                                        ( GHC.Maybe.Just (GHC.Classes.min old h),+                                          acc+                                        )+                                      | GHC.Base.otherwise ->+                                        ( GHC.Maybe.Just h,+                                          acc+                                        )+                                    _ ->+                                      ( minH,+                                        f GHC.Types.: acc+                                      )+                              )+                              ( GHC.Maybe.Nothing,+                                GHC.Types . []+                              )+                              farExp+                     in Data.Set.Internal.fromList GHC.Base.$+                          ( case minHoriz of+                              GHC.Maybe.Just h -> Symantic.Parser.Grammar.Combinators.SomeFailure (Symantic.Parser.Grammar.Combinators.FailureHorizon @(Symantic.Parser.Machine.Input.InputToken inp) h) GHC.Types.: res+                              GHC.Maybe.Nothing -> res+                          )+                }+   in GHC.ST.runST+        ( let inputToken = Data.Proxy.Proxy :: Data.Proxy.Proxy (Symantic.Parser.Machine.Input.InputToken inp)+           in let _ = "checkHorizon.noCheck"+               in let+                   in let _ = "pushValue"+                       in let _ = "pushValue"+                           in do+                                let dupv = \x -> x+                                reg <- GHC.STRef.newSTRef dupv+                                let _ = "iter"+                                 in let onException loopInput =+                                          let _ = "onException"+                                           in \(!_exn) (!failInp) (!farInp) (!farExp) ->+                                                let _ = "comment: raiseAgainIfConsumed"+                                                 in let _ = "saveInput checkedHorizon=0"+                                                     in let _ = "lift2Value checkedHorizon=0"+                                                         in if ( \( Data.Text.Internal.Text+                                                                      _+                                                                      i+                                                                      _+                                                                    )+                                                                  ( Data.Text.Internal.Text+                                                                      _+                                                                      j+                                                                      _+                                                                    ) -> i GHC.Classes.== j+                                                               )+                                                              loopInput+                                                              failInp+                                                              then+                                                                let _ = "choicesBranch checkedHorizon=0"+                                                                 in do+                                                                      sr <- GHC.STRef.readSTRef reg+                                                                      let _ = "pushValue"+                                                                       in let _ = "lift2Value checkedHorizon=0"+                                                                           in let _ = "lift2Value checkedHorizon=0"+                                                                               in let join = \farInp farExp v (!inp) ->+                                                                                        let _ = "lift2Value checkedHorizon=0"+                                                                                         in let _ = "resume"+                                                                                             in finalRet+                                                                                                  farInp+                                                                                                  farExp+                                                                                                  ( let _ = "resume.genCode"+                                                                                                     in GHC.Show.show (sr GHC.Types . [])+                                                                                                  )+                                                                                                  inp+                                                                                   in let _ = "catch ExceptionFailure checkedHorizon=0"+                                                                                       in let onException =+                                                                                                let _ = "onException"+                                                                                                 in \(!_exn) (!failInp) (!farInp) (!farExp) ->+                                                                                                      let _ = "comment: raiseAgainIfConsumed"+                                                                                                       in let _ = "saveInput checkedHorizon=0"+                                                                                                           in let _ = "lift2Value checkedHorizon=0"+                                                                                                               in if ( \( Data.Text.Internal.Text+                                                                                                                            _+                                                                                                                            i+                                                                                                                            _+                                                                                                                          )+                                                                                                                        ( Data.Text.Internal.Text+                                                                                                                            _+                                                                                                                            j+                                                                                                                            _+                                                                                                                          ) -> i GHC.Classes.== j+                                                                                                                     )+                                                                                                                    failInp+                                                                                                                    failInp+                                                                                                                    then+                                                                                                                      let _ = "choicesBranch checkedHorizon=0"+                                                                                                                       in let _ = "comment: eof.fail"+                                                                                                                           in let failExp = Data.Set.Internal.Bin 1 (Symantic.Parser.Grammar.Combinators.SomeFailure Symantic.Parser.Grammar.Combinators.FailureEnd) Data.Set.Internal.Tip Data.Set.Internal.Tip+                                                                                                                               in let (#+                                                                                                                                        farInp,+                                                                                                                                        farExp+                                                                                                                                        #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp failInp of+                                                                                                                                          GHC.Types.LT ->+                                                                                                                                            (#+                                                                                                                                              failInp,+                                                                                                                                              failExp+                                                                                                                                            #)+                                                                                                                                          GHC.Types.EQ ->+                                                                                                                                            (#+                                                                                                                                              farInp,+                                                                                                                                              failExp GHC.Base.<> farExp+                                                                                                                                            #)+                                                                                                                                          GHC.Types.GT ->+                                                                                                                                            (#+                                                                                                                                              farInp,+                                                                                                                                              farExp+                                                                                                                                            #)+                                                                                                                                   in finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp farInp farExp+                                                                                                                    else+                                                                                                                      let _ = "choicesBranch.else"+                                                                                                                       in finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp farInp farExp+                                                                                           in let _ = "comment: negLook"+                                                                                               in let _ = "catch ExceptionFailure checkedHorizon=0"+                                                                                                   in let onException =+                                                                                                            let _ = "onException"+                                                                                                             in \(!_exn) (!failInp) (!farInp) (!farExp) ->+                                                                                                                  let _ = "comment: negLook.reset"+                                                                                                                   in let _ = "loadInput checkedHorizon=0"+                                                                                                                       in let _ = "checkHorizon.noCheck"+                                                                                                                           in let _ = "pushValue"+                                                                                                                               in let _ = "commit"+                                                                                                                                   in let _ = "resume"+                                                                                                                                       in join+                                                                                                                                            farInp+                                                                                                                                            farExp+                                                                                                                                            ( let _ = "resume.genCode"+                                                                                                                                               in GHC.Tuple . ()+                                                                                                                                            )+                                                                                                                                            failInp+                                                                                                       in let _ = "comment: negLook.ahead"+                                                                                                           in let _ = "saveInput checkedHorizon=0"+                                                                                                               in let _ = "comment: satisfy ((\\x_0 -> \\x_1 -> x_0) GHC.Types.True)"+                                                                                                                   in let inp = failInp+                                                                                                                       in let readFail = onException+                                                                                                                           in let _ = "checkHorizon.newCheck: checkedHorizon=0 minHoriz=1"+                                                                                                                               in if readMore inp+                                                                                                                                    then+                                                                                                                                      let _ = "checkToken"+                                                                                                                                       in let !(#+                                                                                                                                                 c,+                                                                                                                                                 cs+                                                                                                                                                 #) = readNext inp+                                                                                                                                           in let _ = "popValue"+                                                                                                                                               in let _ = "commit"+                                                                                                                                                   in let _ = "loadInput checkedHorizon=0"+                                                                                                                                                       in let _ = "checkHorizon.noCheck"+                                                                                                                                                           in onException Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp farInp farExp+                                                                                                                                    else+                                                                                                                                      let _ = "checkHorizon.newCheck.fail"+                                                                                                                                       in let failExp =+                                                                                                                                                Data.Set.Internal.Bin+                                                                                                                                                  1+                                                                                                                                                  ( Symantic.Parser.Grammar.Combinators.SomeFailure+                                                                                                                                                      ( case inputToken of+                                                                                                                                                          (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureHorizon @tok' 1+                                                                                                                                                      )+                                                                                                                                                  )+                                                                                                                                                  Data.Set.Internal.Tip+                                                                                                                                                  Data.Set.Internal.Tip+                                                                                                                                           in let (#+                                                                                                                                                    farInp,+                                                                                                                                                    farExp+                                                                                                                                                    #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp inp of+                                                                                                                                                      GHC.Types.LT ->+                                                                                                                                                        (#+                                                                                                                                                          inp,+                                                                                                                                                          failExp+                                                                                                                                                        #)+                                                                                                                                                      GHC.Types.EQ ->+                                                                                                                                                        (#+                                                                                                                                                          farInp,+                                                                                                                                                          failExp GHC.Base.<> farExp+                                                                                                                                                        #)+                                                                                                                                                      GHC.Types.GT ->+                                                                                                                                                        (#+                                                                                                                                                          farInp,+                                                                                                                                                          farExp+                                                                                                                                                        #)+                                                                                                                                               in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp+                                                              else+                                                                let _ = "choicesBranch.else"+                                                                 in finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp farInp farExp+                                        loop = \_callerOnReturn callerInput callerOnExceptionStackByLabel ->+                                          let _ = "pushValue"+                                           in let _ = "comment: satisfy (\\t_0 -> ('a' GHC.Classes.== t_0) GHC.Classes.|| (('b' GHC.Classes.== t_0) GHC.Classes.|| (('c' GHC.Classes.== t_0) GHC.Classes.|| (('d' GHC.Classes.== t_0) GHC.Classes.|| GHC.Types.False))))"+                                               in let inp = callerInput+                                                   in let readFail = onException callerInput+                                                       in let _ = "checkHorizon.newCheck: checkedHorizon=0 minHoriz=1"+                                                           in if readMore inp+                                                                then+                                                                  let _ = "checkToken"+                                                                   in let !(#+                                                                             c,+                                                                             cs+                                                                             #) = readNext inp+                                                                       in if (\t -> ('a' GHC.Classes.== t) GHC.Classes.|| (('b' GHC.Classes.== t) GHC.Classes.|| (('c' GHC.Classes.== t) GHC.Classes.|| (('d' GHC.Classes.== t) GHC.Classes.|| GHC.Types.False)))) c+                                                                            then+                                                                              let _ = "lift2Value checkedHorizon=1"+                                                                               in let _ = "pushValue"+                                                                                   in let _ = "lift2Value checkedHorizon=1"+                                                                                       in do+                                                                                            sr <- GHC.STRef.readSTRef reg+                                                                                            let _ = "lift2Value checkedHorizon=1"+                                                                                             in do+                                                                                                  let dupv = \x -> sr ((GHC.Types.:) c x)+                                                                                                  GHC.STRef.writeSTRef reg dupv+                                                                                                  let _ = "jump"+                                                                                                   in loop (GHC.Err.error "invalid onReturn") cs (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure readFail Data.Map.Internal.Tip Data.Map.Internal.Tip)+                                                                            else+                                                                              let _ = "checkToken.fail"+                                                                               in let failExp =+                                                                                        Data.Set.Internal.Bin+                                                                                          4+                                                                                          ( Symantic.Parser.Grammar.Combinators.SomeFailure+                                                                                              ( case inputToken of+                                                                                                  (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken 'b'+                                                                                              )+                                                                                          )+                                                                                          ( Data.Set.Internal.Bin+                                                                                              1+                                                                                              ( Symantic.Parser.Grammar.Combinators.SomeFailure+                                                                                                  ( case inputToken of+                                                                                                      (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken 'a'+                                                                                                  )+                                                                                              )+                                                                                              Data.Set.Internal.Tip+                                                                                              Data.Set.Internal.Tip+                                                                                          )+                                                                                          ( Data.Set.Internal.Bin+                                                                                              2+                                                                                              ( Symantic.Parser.Grammar.Combinators.SomeFailure+                                                                                                  ( case inputToken of+                                                                                                      (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken 'c'+                                                                                                  )+                                                                                              )+                                                                                              Data.Set.Internal.Tip+                                                                                              ( Data.Set.Internal.Bin+                                                                                                  1+                                                                                                  ( Symantic.Parser.Grammar.Combinators.SomeFailure+                                                                                                      ( case inputToken of+                                                                                                          (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken 'd'+                                                                                                      )+                                                                                                  )+                                                                                                  Data.Set.Internal.Tip+                                                                                                  Data.Set.Internal.Tip+                                                                                              )+                                                                                          )+                                                                                   in let (#+                                                                                            farInp,+                                                                                            farExp+                                                                                            #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init inp of+                                                                                              GHC.Types.LT ->+                                                                                                (#+                                                                                                  inp,+                                                                                                  failExp+                                                                                                #)+                                                                                              GHC.Types.EQ ->+                                                                                                (#+                                                                                                  init,+                                                                                                  failExp GHC.Base.<> Data.Set.Internal.empty+                                                                                                #)+                                                                                              GHC.Types.GT ->+                                                                                                (#+                                                                                                  init,+                                                                                                  Data.Set.Internal.empty+                                                                                                #)+                                                                                       in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp+                                                                else+                                                                  let _ = "checkHorizon.newCheck.fail"+                                                                   in let failExp =+                                                                            Data.Set.Internal.Bin+                                                                              1+                                                                              ( Symantic.Parser.Grammar.Combinators.SomeFailure+                                                                                  ( case inputToken of+                                                                                      (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureHorizon @tok' 1+                                                                                  )+                                                                              )+                                                                              Data.Set.Internal.Tip+                                                                              Data.Set.Internal.Tip+                                                                       in let (#+                                                                                farInp,+                                                                                farExp+                                                                                #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init inp of+                                                                                  GHC.Types.LT ->+                                                                                    (#+                                                                                      inp,+                                                                                      failExp+                                                                                    #)+                                                                                  GHC.Types.EQ ->+                                                                                    (#+                                                                                      init,+                                                                                      failExp GHC.Base.<> Data.Set.Internal.empty+                                                                                    #)+                                                                                  GHC.Types.GT ->+                                                                                    (#+                                                                                      init,+                                                                                      Data.Set.Internal.empty+                                                                                    #)+                                                                           in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp+                                     in let _ = "jump"+                                         in loop finalRet init Data.Map.Internal.Tip+        )
+ tests/Golden/Splice/G13.expected.txt view
@@ -0,0 +1,603 @@+\(input :: inp) ->+  let !(#+         init,+         readMore,+         readNext+         #) =+          let _ = "cursorOf"+           in let next+                    ( t@( Data.Text.Internal.Text+                            arr+                            off+                            unconsumed+                          )+                      ) =+                      let !( Data.Text.Unsafe.Iter+                               c+                               d+                             ) = Data.Text.Unsafe.iter t 0+                       in (#+                            c,+                            Data.Text.Internal.Text arr (off GHC.Num.+ d) (unconsumed GHC.Num.- d)+                          #)+                  more+                    ( Data.Text.Internal.Text+                        _+                        _+                        unconsumed+                      ) = unconsumed GHC.Classes.> 0+               in (# input, more, next #)+      finalRet = \_farInp _farExp v _inp -> Symantic.Parser.Machine.Generate.returnST GHC.Base.$ Data.Either.Right v+      finalRaise ::+        forall st b.+        Symantic.Parser.Machine.Generate.OnException+          st+          inp+          b = \(!exn) _failInp (!farInp) (!farExp) ->+          Symantic.Parser.Machine.Generate.returnST GHC.Base.$+            Data.Either.Left+              Symantic.Parser.Machine.Generate.ParsingError+                { Symantic.Parser.Machine.Generate.parsingErrorOffset = Symantic.Parser.Machine.Input.offset farInp,+                  Symantic.Parser.Machine.Generate.parsingErrorException = exn,+                  Symantic.Parser.Machine.Generate.parsingErrorUnexpected =+                    if readMore farInp+                      then+                        GHC.Maybe.Just+                          ( let (#+                                  c,+                                  _+                                  #) = readNext farInp+                             in c+                          )+                      else GHC.Maybe.Nothing,+                  Symantic.Parser.Machine.Generate.parsingErrorExpecting =+                    let ( minHoriz,+                          res+                          ) =+                            Data.Set.Internal.foldr+                              ( \f+                                 ( minH,+                                   acc+                                   ) -> case Symantic.Parser.Grammar.Combinators.unSomeFailure f of+                                    GHC.Maybe.Just (Symantic.Parser.Grammar.Combinators.FailureHorizon h :: Symantic.Parser.Grammar.Combinators.Failure (Symantic.Parser.Grammar.Combinators.CombSatisfiable (Symantic.Parser.Machine.Input.InputToken inp)))+                                      | GHC.Maybe.Just old <- minH ->+                                        ( GHC.Maybe.Just (GHC.Classes.min old h),+                                          acc+                                        )+                                      | GHC.Base.otherwise ->+                                        ( GHC.Maybe.Just h,+                                          acc+                                        )+                                    _ ->+                                      ( minH,+                                        f GHC.Types.: acc+                                      )+                              )+                              ( GHC.Maybe.Nothing,+                                GHC.Types . []+                              )+                              farExp+                     in Data.Set.Internal.fromList GHC.Base.$+                          ( case minHoriz of+                              GHC.Maybe.Just h -> Symantic.Parser.Grammar.Combinators.SomeFailure (Symantic.Parser.Grammar.Combinators.FailureHorizon @(Symantic.Parser.Machine.Input.InputToken inp) h) GHC.Types.: res+                              GHC.Maybe.Nothing -> res+                          )+                }+   in GHC.ST.runST+        ( let inputToken = Data.Proxy.Proxy :: Data.Proxy.Proxy (Symantic.Parser.Machine.Input.InputToken inp)+           in let _ = "checkHorizon.noCheck"+               in let name = \(!callerOnReturn) (!callerInput) (!callerOnExceptionStackByLabel) ->+                        let _ = "pushValue"+                         in let _ = "pushValue"+                             in do+                                  let dupv = \x -> x+                                  reg <- GHC.STRef.newSTRef dupv+                                  let _ = "iter"+                                   in let onException loopInput =+                                            let _ = "onException"+                                             in \(!_exn) (!failInp) (!farInp) (!farExp) ->+                                                  let _ = "comment: raiseAgainIfConsumed"+                                                   in let _ = "saveInput checkedHorizon=0"+                                                       in let _ = "lift2Value checkedHorizon=0"+                                                           in if ( \( Data.Text.Internal.Text+                                                                        _+                                                                        i+                                                                        _+                                                                      )+                                                                    ( Data.Text.Internal.Text+                                                                        _+                                                                        j+                                                                        _+                                                                      ) -> i GHC.Classes.== j+                                                                 )+                                                                loopInput+                                                                failInp+                                                                then+                                                                  let _ = "choicesBranch checkedHorizon=0"+                                                                   in do+                                                                        sr <- GHC.STRef.readSTRef reg+                                                                        let _ = "pushValue"+                                                                         in let _ = "lift2Value checkedHorizon=0"+                                                                             in let _ = "lift2Value checkedHorizon=0"+                                                                                 in let _ = "resume"+                                                                                     in callerOnReturn+                                                                                          farInp+                                                                                          farExp+                                                                                          ( let _ = "resume.genCode"+                                                                                             in GHC.Tuple . ()+                                                                                          )+                                                                                          failInp+                                                                else+                                                                  let _ = "choicesBranch.else"+                                                                   in Data.Map.Strict.Internal.findWithDefault finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure callerOnExceptionStackByLabel Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp farInp farExp+                                          loop = \_callerOnReturn callerInput callerOnExceptionStackByLabel ->+                                            let _ = "pushValue"+                                             in let _ = "comment: satisfy (\\c_0 -> GHC.Classes.not (('<' GHC.Classes.== c_0) GHC.Classes.|| (('>' GHC.Classes.== c_0) GHC.Classes.|| (('+' GHC.Classes.== c_0) GHC.Classes.|| (('-' GHC.Classes.== c_0) GHC.Classes.|| ((',' GHC.Classes.== c_0) GHC.Classes.|| (('.' GHC.Classes.== c_0) GHC.Classes.|| (('[' GHC.Classes.== c_0) GHC.Classes.|| ((']' GHC.Classes.== c_0) GHC.Classes.|| GHC.Types.False)))))))))"+                                                 in let inp = callerInput+                                                     in let readFail = onException callerInput+                                                         in let _ = "checkHorizon.newCheck: checkedHorizon=0 minHoriz=1"+                                                             in if readMore inp+                                                                  then+                                                                    let _ = "checkToken"+                                                                     in let !(#+                                                                               c,+                                                                               cs+                                                                               #) = readNext inp+                                                                         in if (\c -> GHC.Classes.not (('<' GHC.Classes.== c) GHC.Classes.|| (('>' GHC.Classes.== c) GHC.Classes.|| (('+' GHC.Classes.== c) GHC.Classes.|| (('-' GHC.Classes.== c) GHC.Classes.|| ((',' GHC.Classes.== c) GHC.Classes.|| (('.' GHC.Classes.== c) GHC.Classes.|| (('[' GHC.Classes.== c) GHC.Classes.|| ((']' GHC.Classes.== c) GHC.Classes.|| GHC.Types.False))))))))) c+                                                                              then+                                                                                let _ = "lift2Value checkedHorizon=1"+                                                                                 in do+                                                                                      sr <- GHC.STRef.readSTRef reg+                                                                                      let _ = "lift2Value checkedHorizon=1"+                                                                                       in do+                                                                                            let dupv = sr+                                                                                            GHC.STRef.writeSTRef reg dupv+                                                                                            let _ = "jump"+                                                                                             in loop (GHC.Err.error "invalid onReturn") cs (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure readFail Data.Map.Internal.Tip Data.Map.Internal.Tip)+                                                                              else+                                                                                let _ = "checkToken.fail"+                                                                                 in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure inp init Data.Set.Internal.empty+                                                                  else+                                                                    let _ = "checkHorizon.newCheck.fail"+                                                                     in let failExp =+                                                                              Data.Set.Internal.Bin+                                                                                1+                                                                                ( Symantic.Parser.Grammar.Combinators.SomeFailure+                                                                                    ( case inputToken of+                                                                                        (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureHorizon @tok' 1+                                                                                    )+                                                                                )+                                                                                Data.Set.Internal.Tip+                                                                                Data.Set.Internal.Tip+                                                                         in let (#+                                                                                  farInp,+                                                                                  farExp+                                                                                  #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init inp of+                                                                                    GHC.Types.LT ->+                                                                                      (#+                                                                                        inp,+                                                                                        failExp+                                                                                      #)+                                                                                    GHC.Types.EQ ->+                                                                                      (#+                                                                                        init,+                                                                                        failExp GHC.Base.<> Data.Set.Internal.empty+                                                                                      #)+                                                                                    GHC.Types.GT ->+                                                                                      (#+                                                                                        init,+                                                                                        Data.Set.Internal.empty+                                                                                      #)+                                                                             in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp+                                       in let _ = "jump"+                                           in loop callerOnReturn callerInput (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure (Data.Map.Strict.Internal.findWithDefault finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure callerOnExceptionStackByLabel) Data.Map.Internal.Tip Data.Map.Internal.Tip)+                      name = \(!callerOnReturn) (!callerInput) (!callerOnExceptionStackByLabel) ->+                        let _ = "pushValue"+                         in do+                              let dupv = \x -> x+                              reg <- GHC.STRef.newSTRef dupv+                              let _ = "iter"+                               in let onException loopInput =+                                        let _ = "onException"+                                         in \(!_exn) (!failInp) (!farInp) (!farExp) ->+                                              let _ = "comment: raiseAgainIfConsumed"+                                               in let _ = "saveInput checkedHorizon=0"+                                                   in let _ = "lift2Value checkedHorizon=0"+                                                       in if ( \( Data.Text.Internal.Text+                                                                    _+                                                                    i+                                                                    _+                                                                  )+                                                                ( Data.Text.Internal.Text+                                                                    _+                                                                    j+                                                                    _+                                                                  ) -> i GHC.Classes.== j+                                                             )+                                                            loopInput+                                                            failInp+                                                            then+                                                              let _ = "choicesBranch checkedHorizon=0"+                                                               in do+                                                                    sr <- GHC.STRef.readSTRef reg+                                                                    let _ = "pushValue"+                                                                     in let _ = "lift2Value checkedHorizon=0"+                                                                         in let _ = "resume"+                                                                             in callerOnReturn+                                                                                  farInp+                                                                                  farExp+                                                                                  ( let _ = "resume.genCode"+                                                                                     in sr GHC.Types . []+                                                                                  )+                                                                                  failInp+                                                            else+                                                              let _ = "choicesBranch.else"+                                                               in Data.Map.Strict.Internal.findWithDefault finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure callerOnExceptionStackByLabel Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp farInp farExp+                                      loop = \_callerOnReturn callerInput callerOnExceptionStackByLabel ->+                                        let _ = "pushValue"+                                         in let join = \farInp farExp v (!inp) ->+                                                  let _ = "lift2Value checkedHorizon=0"+                                                   in name+                                                        ( let _ = "onReturn"+                                                           in \farInp farExp v (!inp) ->+                                                                let _ = "lift2Value checkedHorizon=0"+                                                                 in let _ = "pushValue"+                                                                     in let _ = "lift2Value checkedHorizon=0"+                                                                         in do+                                                                              sr <- GHC.STRef.readSTRef reg+                                                                              let _ = "lift2Value checkedHorizon=0"+                                                                               in do+                                                                                    let dupv = \x -> sr ((GHC.Types.:) v x)+                                                                                    GHC.STRef.writeSTRef reg dupv+                                                                                    let _ = "jump"+                                                                                     in loop (GHC.Err.error "invalid onReturn") inp (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure (onException callerInput) Data.Map.Internal.Tip Data.Map.Internal.Tip)+                                                        )+                                                        inp+                                                        (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure (onException callerInput) Data.Map.Internal.Tip Data.Map.Internal.Tip)+                                             in let _ = "comment: look"+                                                 in let _ = "saveInput checkedHorizon=0"+                                                     in let _ = "comment: satisfy ((\\x_0 -> \\x_1 -> x_0) GHC.Types.True)"+                                                         in let inp = callerInput+                                                             in let readFail = onException callerInput+                                                                 in let _ = "checkHorizon.newCheck: checkedHorizon=0 minHoriz=1"+                                                                     in if readMore inp+                                                                          then+                                                                            let _ = "checkToken"+                                                                             in let !(#+                                                                                       c,+                                                                                       cs+                                                                                       #) = readNext inp+                                                                                 in let _ = "loadInput checkedHorizon=0"+                                                                                     in let inp = callerInput+                                                                                         in let readFail = readFail+                                                                                             in let _ = "checkHorizon.newCheck: checkedHorizon=0 minHoriz=1"+                                                                                                 in if readMore inp+                                                                                                      then+                                                                                                        if (\x -> (\x -> \x -> (GHC.Classes.==) x x) '<' x) c+                                                                                                          then+                                                                                                            let _ = "choicesBranch checkedHorizon=1"+                                                                                                             in let _ = "pushValue"+                                                                                                                 in let _ = "comment: satisfy ((\\x_0 -> \\x_1 -> x_0) GHC.Types.True)"+                                                                                                                     in let _ = "checkHorizon.oldCheck: checkedHorizon=1"+                                                                                                                         in let _ = "checkToken"+                                                                                                                             in let !(#+                                                                                                                                       c,+                                                                                                                                       cs+                                                                                                                                       #) = readNext inp+                                                                                                                                 in let _ = "lift2Value checkedHorizon=0"+                                                                                                                                     in let _ = "resume"+                                                                                                                                         in join+                                                                                                                                              init+                                                                                                                                              Data.Set.Internal.empty+                                                                                                                                              ( let _ = "resume.genCode"+                                                                                                                                                 in Parsers.Brainfuck.Types.Backward+                                                                                                                                              )+                                                                                                                                              cs+                                                                                                          else+                                                                                                            let _ = "choicesBranch.else"+                                                                                                             in if (\x -> (\x -> \x -> (GHC.Classes.==) x x) '>' x) c+                                                                                                                  then+                                                                                                                    let _ = "choicesBranch checkedHorizon=1"+                                                                                                                     in let _ = "pushValue"+                                                                                                                         in let _ = "comment: satisfy ((\\x_0 -> \\x_1 -> x_0) GHC.Types.True)"+                                                                                                                             in let _ = "checkHorizon.oldCheck: checkedHorizon=1"+                                                                                                                                 in let _ = "checkToken"+                                                                                                                                     in let !(#+                                                                                                                                               c,+                                                                                                                                               cs+                                                                                                                                               #) = readNext inp+                                                                                                                                         in let _ = "lift2Value checkedHorizon=0"+                                                                                                                                             in let _ = "resume"+                                                                                                                                                 in join+                                                                                                                                                      init+                                                                                                                                                      Data.Set.Internal.empty+                                                                                                                                                      ( let _ = "resume.genCode"+                                                                                                                                                         in Parsers.Brainfuck.Types.Forward+                                                                                                                                                      )+                                                                                                                                                      cs+                                                                                                                  else+                                                                                                                    let _ = "choicesBranch.else"+                                                                                                                     in if (\x -> (\x -> \x -> (GHC.Classes.==) x x) '+' x) c+                                                                                                                          then+                                                                                                                            let _ = "choicesBranch checkedHorizon=1"+                                                                                                                             in let _ = "pushValue"+                                                                                                                                 in let _ = "comment: satisfy ((\\x_0 -> \\x_1 -> x_0) GHC.Types.True)"+                                                                                                                                     in let _ = "checkHorizon.oldCheck: checkedHorizon=1"+                                                                                                                                         in let _ = "checkToken"+                                                                                                                                             in let !(#+                                                                                                                                                       c,+                                                                                                                                                       cs+                                                                                                                                                       #) = readNext inp+                                                                                                                                                 in let _ = "lift2Value checkedHorizon=0"+                                                                                                                                                     in let _ = "resume"+                                                                                                                                                         in join+                                                                                                                                                              init+                                                                                                                                                              Data.Set.Internal.empty+                                                                                                                                                              ( let _ = "resume.genCode"+                                                                                                                                                                 in Parsers.Brainfuck.Types.Increment+                                                                                                                                                              )+                                                                                                                                                              cs+                                                                                                                          else+                                                                                                                            let _ = "choicesBranch.else"+                                                                                                                             in if (\x -> (\x -> \x -> (GHC.Classes.==) x x) '-' x) c+                                                                                                                                  then+                                                                                                                                    let _ = "choicesBranch checkedHorizon=1"+                                                                                                                                     in let _ = "pushValue"+                                                                                                                                         in let _ = "comment: satisfy ((\\x_0 -> \\x_1 -> x_0) GHC.Types.True)"+                                                                                                                                             in let _ = "checkHorizon.oldCheck: checkedHorizon=1"+                                                                                                                                                 in let _ = "checkToken"+                                                                                                                                                     in let !(#+                                                                                                                                                               c,+                                                                                                                                                               cs+                                                                                                                                                               #) = readNext inp+                                                                                                                                                         in let _ = "lift2Value checkedHorizon=0"+                                                                                                                                                             in let _ = "resume"+                                                                                                                                                                 in join+                                                                                                                                                                      init+                                                                                                                                                                      Data.Set.Internal.empty+                                                                                                                                                                      ( let _ = "resume.genCode"+                                                                                                                                                                         in Parsers.Brainfuck.Types.Decrement+                                                                                                                                                                      )+                                                                                                                                                                      cs+                                                                                                                                  else+                                                                                                                                    let _ = "choicesBranch.else"+                                                                                                                                     in if (\x -> (\x -> \x -> (GHC.Classes.==) x x) ',' x) c+                                                                                                                                          then+                                                                                                                                            let _ = "choicesBranch checkedHorizon=1"+                                                                                                                                             in let _ = "pushValue"+                                                                                                                                                 in let _ = "comment: satisfy ((\\x_0 -> \\x_1 -> x_0) GHC.Types.True)"+                                                                                                                                                     in let _ = "checkHorizon.oldCheck: checkedHorizon=1"+                                                                                                                                                         in let _ = "checkToken"+                                                                                                                                                             in let !(#+                                                                                                                                                                       c,+                                                                                                                                                                       cs+                                                                                                                                                                       #) = readNext inp+                                                                                                                                                                 in let _ = "lift2Value checkedHorizon=0"+                                                                                                                                                                     in let _ = "resume"+                                                                                                                                                                         in join+                                                                                                                                                                              init+                                                                                                                                                                              Data.Set.Internal.empty+                                                                                                                                                                              ( let _ = "resume.genCode"+                                                                                                                                                                                 in Parsers.Brainfuck.Types.Input+                                                                                                                                                                              )+                                                                                                                                                                              cs+                                                                                                                                          else+                                                                                                                                            let _ = "choicesBranch.else"+                                                                                                                                             in if (\x -> (\x -> \x -> (GHC.Classes.==) x x) '.' x) c+                                                                                                                                                  then+                                                                                                                                                    let _ = "choicesBranch checkedHorizon=1"+                                                                                                                                                     in let _ = "pushValue"+                                                                                                                                                         in let _ = "comment: satisfy ((\\x_0 -> \\x_1 -> x_0) GHC.Types.True)"+                                                                                                                                                             in let _ = "checkHorizon.oldCheck: checkedHorizon=1"+                                                                                                                                                                 in let _ = "checkToken"+                                                                                                                                                                     in let !(#+                                                                                                                                                                               c,+                                                                                                                                                                               cs+                                                                                                                                                                               #) = readNext inp+                                                                                                                                                                         in let _ = "lift2Value checkedHorizon=0"+                                                                                                                                                                             in let _ = "resume"+                                                                                                                                                                                 in join+                                                                                                                                                                                      init+                                                                                                                                                                                      Data.Set.Internal.empty+                                                                                                                                                                                      ( let _ = "resume.genCode"+                                                                                                                                                                                         in Parsers.Brainfuck.Types.Output+                                                                                                                                                                                      )+                                                                                                                                                                                      cs+                                                                                                                                                  else+                                                                                                                                                    let _ = "choicesBranch.else"+                                                                                                                                                     in if (\x -> (\x -> \x -> (GHC.Classes.==) x x) '[' x) c+                                                                                                                                                          then+                                                                                                                                                            let _ = "choicesBranch checkedHorizon=1"+                                                                                                                                                             in let _ = "pushValue"+                                                                                                                                                                 in let _ = "comment: satisfy ((\\x_0 -> \\x_1 -> x_0) GHC.Types.True)"+                                                                                                                                                                     in let _ = "checkHorizon.oldCheck: checkedHorizon=1"+                                                                                                                                                                         in let _ = "checkToken"+                                                                                                                                                                             in let !(#+                                                                                                                                                                                       c,+                                                                                                                                                                                       cs+                                                                                                                                                                                       #) = readNext inp+                                                                                                                                                                                 in let _ = "lift2Value checkedHorizon=0"+                                                                                                                                                                                     in name+                                                                                                                                                                                          ( let _ = "onReturn"+                                                                                                                                                                                             in \farInp farExp v (!inp) ->+                                                                                                                                                                                                  let _ = "lift2Value checkedHorizon=0"+                                                                                                                                                                                                   in name+                                                                                                                                                                                                        ( let _ = "onReturn"+                                                                                                                                                                                                           in \farInp farExp v (!inp) ->+                                                                                                                                                                                                                let _ = "lift2Value checkedHorizon=0"+                                                                                                                                                                                                                 in let _ = "comment: satisfy ((GHC.Classes.==) ']')"+                                                                                                                                                                                                                     in let inp = inp+                                                                                                                                                                                                                         in let readFail = readFail+                                                                                                                                                                                                                             in let _ = "checkHorizon.newCheck: checkedHorizon=0 minHoriz=1"+                                                                                                                                                                                                                                 in if readMore inp+                                                                                                                                                                                                                                      then+                                                                                                                                                                                                                                        let _ = "checkToken"+                                                                                                                                                                                                                                         in let !(#+                                                                                                                                                                                                                                                   c,+                                                                                                                                                                                                                                                   cs+                                                                                                                                                                                                                                                   #) = readNext inp+                                                                                                                                                                                                                                             in if (GHC.Classes.==) ']' c+                                                                                                                                                                                                                                                  then+                                                                                                                                                                                                                                                    let _ = "lift2Value checkedHorizon=1"+                                                                                                                                                                                                                                                     in let _ = "resume"+                                                                                                                                                                                                                                                         in join+                                                                                                                                                                                                                                                              farInp+                                                                                                                                                                                                                                                              farExp+                                                                                                                                                                                                                                                              ( let _ = "resume.genCode"+                                                                                                                                                                                                                                                                 in Parsers.Brainfuck.Types.Loop v+                                                                                                                                                                                                                                                              )+                                                                                                                                                                                                                                                              cs+                                                                                                                                                                                                                                                  else+                                                                                                                                                                                                                                                    let _ = "checkToken.fail"+                                                                                                                                                                                                                                                     in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp+                                                                                                                                                                                                                                      else+                                                                                                                                                                                                                                        let _ = "checkHorizon.newCheck.fail"+                                                                                                                                                                                                                                         in let failExp =+                                                                                                                                                                                                                                                  Data.Set.Internal.Bin+                                                                                                                                                                                                                                                    1+                                                                                                                                                                                                                                                    ( Symantic.Parser.Grammar.Combinators.SomeFailure+                                                                                                                                                                                                                                                        ( case inputToken of+                                                                                                                                                                                                                                                            (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureHorizon @tok' 1+                                                                                                                                                                                                                                                        )+                                                                                                                                                                                                                                                    )+                                                                                                                                                                                                                                                    Data.Set.Internal.Tip+                                                                                                                                                                                                                                                    Data.Set.Internal.Tip+                                                                                                                                                                                                                                             in let (#+                                                                                                                                                                                                                                                      farInp,+                                                                                                                                                                                                                                                      farExp+                                                                                                                                                                                                                                                      #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp inp of+                                                                                                                                                                                                                                                        GHC.Types.LT ->+                                                                                                                                                                                                                                                          (#+                                                                                                                                                                                                                                                            inp,+                                                                                                                                                                                                                                                            failExp+                                                                                                                                                                                                                                                          #)+                                                                                                                                                                                                                                                        GHC.Types.EQ ->+                                                                                                                                                                                                                                                          (#+                                                                                                                                                                                                                                                            farInp,+                                                                                                                                                                                                                                                            failExp GHC.Base.<> farExp+                                                                                                                                                                                                                                                          #)+                                                                                                                                                                                                                                                        GHC.Types.GT ->+                                                                                                                                                                                                                                                          (#+                                                                                                                                                                                                                                                            farInp,+                                                                                                                                                                                                                                                            farExp+                                                                                                                                                                                                                                                          #)+                                                                                                                                                                                                                                                 in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp+                                                                                                                                                                                                        )+                                                                                                                                                                                                        inp+                                                                                                                                                                                                        (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure readFail Data.Map.Internal.Tip Data.Map.Internal.Tip)+                                                                                                                                                                                          )+                                                                                                                                                                                          cs+                                                                                                                                                                                          (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure readFail Data.Map.Internal.Tip Data.Map.Internal.Tip)+                                                                                                                                                          else+                                                                                                                                                            let _ = "choicesBranch.else"+                                                                                                                                                             in let failExp = Data.Set.Internal.Bin 1 (Symantic.Parser.Grammar.Combinators.SomeFailure Symantic.Parser.Grammar.Combinators.FailureEmpty) Data.Set.Internal.Tip Data.Set.Internal.Tip+                                                                                                                                                                 in let (#+                                                                                                                                                                          farInp,+                                                                                                                                                                          farExp+                                                                                                                                                                          #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init inp of+                                                                                                                                                                            GHC.Types.LT ->+                                                                                                                                                                              (#+                                                                                                                                                                                inp,+                                                                                                                                                                                failExp+                                                                                                                                                                              #)+                                                                                                                                                                            GHC.Types.EQ ->+                                                                                                                                                                              (#+                                                                                                                                                                                init,+                                                                                                                                                                                failExp GHC.Base.<> Data.Set.Internal.empty+                                                                                                                                                                              #)+                                                                                                                                                                            GHC.Types.GT ->+                                                                                                                                                                              (#+                                                                                                                                                                                init,+                                                                                                                                                                                Data.Set.Internal.empty+                                                                                                                                                                              #)+                                                                                                                                                                     in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp+                                                                                                      else+                                                                                                        let _ = "checkHorizon.newCheck.fail"+                                                                                                         in let failExp =+                                                                                                                  Data.Set.Internal.Bin+                                                                                                                    1+                                                                                                                    ( Symantic.Parser.Grammar.Combinators.SomeFailure+                                                                                                                        ( case inputToken of+                                                                                                                            (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureHorizon @tok' 1+                                                                                                                        )+                                                                                                                    )+                                                                                                                    Data.Set.Internal.Tip+                                                                                                                    Data.Set.Internal.Tip+                                                                                                             in let (#+                                                                                                                      farInp,+                                                                                                                      farExp+                                                                                                                      #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init inp of+                                                                                                                        GHC.Types.LT ->+                                                                                                                          (#+                                                                                                                            inp,+                                                                                                                            failExp+                                                                                                                          #)+                                                                                                                        GHC.Types.EQ ->+                                                                                                                          (#+                                                                                                                            init,+                                                                                                                            failExp GHC.Base.<> Data.Set.Internal.empty+                                                                                                                          #)+                                                                                                                        GHC.Types.GT ->+                                                                                                                          (#+                                                                                                                            init,+                                                                                                                            Data.Set.Internal.empty+                                                                                                                          #)+                                                                                                                 in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp+                                                                          else+                                                                            let _ = "checkHorizon.newCheck.fail"+                                                                             in let failExp =+                                                                                      Data.Set.Internal.Bin+                                                                                        1+                                                                                        ( Symantic.Parser.Grammar.Combinators.SomeFailure+                                                                                            ( case inputToken of+                                                                                                (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureHorizon @tok' 1+                                                                                            )+                                                                                        )+                                                                                        Data.Set.Internal.Tip+                                                                                        Data.Set.Internal.Tip+                                                                                 in let (#+                                                                                          farInp,+                                                                                          farExp+                                                                                          #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init inp of+                                                                                            GHC.Types.LT ->+                                                                                              (#+                                                                                                inp,+                                                                                                failExp+                                                                                              #)+                                                                                            GHC.Types.EQ ->+                                                                                              (#+                                                                                                init,+                                                                                                failExp GHC.Base.<> Data.Set.Internal.empty+                                                                                              #)+                                                                                            GHC.Types.GT ->+                                                                                              (#+                                                                                                init,+                                                                                                Data.Set.Internal.empty+                                                                                              #)+                                                                                     in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp+                                   in let _ = "jump"+                                       in loop callerOnReturn callerInput (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure (Data.Map.Strict.Internal.findWithDefault finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure callerOnExceptionStackByLabel) Data.Map.Internal.Tip Data.Map.Internal.Tip)+                   in let _ = "pushValue"+                       in name+                            ( let _ = "onReturn"+                               in \farInp farExp v (!inp) ->+                                    let _ = "lift2Value checkedHorizon=0"+                                     in name+                                          ( let _ = "onReturn"+                                             in \farInp farExp v (!inp) ->+                                                  let _ = "lift2Value checkedHorizon=0"+                                                   in let _ = "resume"+                                                       in finalRet+                                                            farInp+                                                            farExp+                                                            ( let _ = "resume.genCode"+                                                               in GHC.Show.show v+                                                            )+                                                            inp+                                          )+                                          inp+                                          Data.Map.Internal.Tip+                            )+                            init+                            Data.Map.Internal.Tip+        )
+ tests/Golden/Splice/G14.expected.txt view
@@ -0,0 +1,4619 @@+\(input :: inp) ->+  let !(#+         init,+         readMore,+         readNext+         #) =+          let _ = "cursorOf"+           in let next+                    ( t@( Data.Text.Internal.Text+                            arr+                            off+                            unconsumed+                          )+                      ) =+                      let !( Data.Text.Unsafe.Iter+                               c+                               d+                             ) = Data.Text.Unsafe.iter t 0+                       in (#+                            c,+                            Data.Text.Internal.Text arr (off GHC.Num.+ d) (unconsumed GHC.Num.- d)+                          #)+                  more+                    ( Data.Text.Internal.Text+                        _+                        _+                        unconsumed+                      ) = unconsumed GHC.Classes.> 0+               in (# input, more, next #)+      finalRet = \_farInp _farExp v _inp -> Symantic.Parser.Machine.Generate.returnST GHC.Base.$ Data.Either.Right v+      finalRaise ::+        forall st b.+        Symantic.Parser.Machine.Generate.OnException+          st+          inp+          b = \(!exn) _failInp (!farInp) (!farExp) ->+          Symantic.Parser.Machine.Generate.returnST GHC.Base.$+            Data.Either.Left+              Symantic.Parser.Machine.Generate.ParsingError+                { Symantic.Parser.Machine.Generate.parsingErrorOffset = Symantic.Parser.Machine.Input.offset farInp,+                  Symantic.Parser.Machine.Generate.parsingErrorException = exn,+                  Symantic.Parser.Machine.Generate.parsingErrorUnexpected =+                    if readMore farInp+                      then+                        GHC.Maybe.Just+                          ( let (#+                                  c,+                                  _+                                  #) = readNext farInp+                             in c+                          )+                      else GHC.Maybe.Nothing,+                  Symantic.Parser.Machine.Generate.parsingErrorExpecting =+                    let ( minHoriz,+                          res+                          ) =+                            Data.Set.Internal.foldr+                              ( \f+                                 ( minH,+                                   acc+                                   ) -> case Symantic.Parser.Grammar.Combinators.unSomeFailure f of+                                    GHC.Maybe.Just (Symantic.Parser.Grammar.Combinators.FailureHorizon h :: Symantic.Parser.Grammar.Combinators.Failure (Symantic.Parser.Grammar.Combinators.CombSatisfiable (Symantic.Parser.Machine.Input.InputToken inp)))+                                      | GHC.Maybe.Just old <- minH ->+                                        ( GHC.Maybe.Just (GHC.Classes.min old h),+                                          acc+                                        )+                                      | GHC.Base.otherwise ->+                                        ( GHC.Maybe.Just h,+                                          acc+                                        )+                                    _ ->+                                      ( minH,+                                        f GHC.Types.: acc+                                      )+                              )+                              ( GHC.Maybe.Nothing,+                                GHC.Types . []+                              )+                              farExp+                     in Data.Set.Internal.fromList GHC.Base.$+                          ( case minHoriz of+                              GHC.Maybe.Just h -> Symantic.Parser.Grammar.Combinators.SomeFailure (Symantic.Parser.Grammar.Combinators.FailureHorizon @(Symantic.Parser.Machine.Input.InputToken inp) h) GHC.Types.: res+                              GHC.Maybe.Nothing -> res+                          )+                }+   in GHC.ST.runST+        ( let inputToken = Data.Proxy.Proxy :: Data.Proxy.Proxy (Symantic.Parser.Machine.Input.InputToken inp)+           in let inp = init+               in let readFail = finalRaise+                   in let _ = "checkHorizon.newCheck: checkedHorizon=0 minHoriz=1"+                       in if readMore inp+                            then+                              let name = \(!callerOnReturn) (!callerInput) (!callerOnExceptionStackByLabel) ->+                                    let _ = "catch ExceptionFailure checkedHorizon=0"+                                     in let onException =+                                              let _ = "onException"+                                               in \(!_exn) (!failInp) (!farInp) (!farExp) ->+                                                    let _ = "comment: raiseAgainIfConsumed"+                                                     in let _ = "saveInput checkedHorizon=0"+                                                         in let _ = "lift2Value checkedHorizon=0"+                                                             in if ( \( Data.Text.Internal.Text+                                                                          _+                                                                          i+                                                                          _+                                                                        )+                                                                      ( Data.Text.Internal.Text+                                                                          _+                                                                          j+                                                                          _+                                                                        ) -> i GHC.Classes.== j+                                                                   )+                                                                  callerInput+                                                                  failInp+                                                                  then+                                                                    let _ = "choicesBranch checkedHorizon=0"+                                                                     in let _ = "catch ExceptionFailure checkedHorizon=0"+                                                                         in let onException =+                                                                                  let _ = "onException"+                                                                                   in \(!_exn) (!failInp) (!farInp) (!farExp) ->+                                                                                        let _ = "comment: raiseAgainIfConsumed"+                                                                                         in let _ = "saveInput checkedHorizon=0"+                                                                                             in let _ = "lift2Value checkedHorizon=0"+                                                                                                 in if ( \( Data.Text.Internal.Text+                                                                                                              _+                                                                                                              i+                                                                                                              _+                                                                                                            )+                                                                                                          ( Data.Text.Internal.Text+                                                                                                              _+                                                                                                              j+                                                                                                              _+                                                                                                            ) -> i GHC.Classes.== j+                                                                                                       )+                                                                                                      failInp+                                                                                                      failInp+                                                                                                      then+                                                                                                        let _ = "choicesBranch checkedHorizon=0"+                                                                                                         in let _ = "pushValue"+                                                                                                             in name+                                                                                                                  ( let _ = "onReturn"+                                                                                                                     in \farInp farExp v (!inp) ->+                                                                                                                          let _ = "lift2Value checkedHorizon=0"+                                                                                                                           in let join = \farInp farExp v (!inp) ->+                                                                                                                                    let _ = "lift2Value checkedHorizon=0"+                                                                                                                                     in let _ = "resume"+                                                                                                                                         in callerOnReturn+                                                                                                                                              farInp+                                                                                                                                              farExp+                                                                                                                                              ( let _ = "resume.genCode"+                                                                                                                                                 in v+                                                                                                                                              )+                                                                                                                                              inp+                                                                                                                               in let _ = "catch ExceptionFailure checkedHorizon=0"+                                                                                                                                   in let onException =+                                                                                                                                            let _ = "onException"+                                                                                                                                             in \(!_exn) (!failInp) (!farInp) (!farExp) ->+                                                                                                                                                  let _ = "comment: raiseAgainIfConsumed"+                                                                                                                                                   in let _ = "saveInput checkedHorizon=0"+                                                                                                                                                       in let _ = "lift2Value checkedHorizon=0"+                                                                                                                                                           in if ( \( Data.Text.Internal.Text+                                                                                                                                                                        _+                                                                                                                                                                        i+                                                                                                                                                                        _+                                                                                                                                                                      )+                                                                                                                                                                    ( Data.Text.Internal.Text+                                                                                                                                                                        _+                                                                                                                                                                        j+                                                                                                                                                                        _+                                                                                                                                                                      ) -> i GHC.Classes.== j+                                                                                                                                                                 )+                                                                                                                                                                inp+                                                                                                                                                                failInp+                                                                                                                                                                then+                                                                                                                                                                  let _ = "choicesBranch checkedHorizon=0"+                                                                                                                                                                   in name+                                                                                                                                                                        ( let _ = "onReturn"+                                                                                                                                                                           in \farInp farExp v (!inp) ->+                                                                                                                                                                                let _ = "resume"+                                                                                                                                                                                 in join+                                                                                                                                                                                      farInp+                                                                                                                                                                                      farExp+                                                                                                                                                                                      ( let _ = "resume.genCode"+                                                                                                                                                                                         in v+                                                                                                                                                                                      )+                                                                                                                                                                                      inp+                                                                                                                                                                        )+                                                                                                                                                                        failInp+                                                                                                                                                                        Data.Map.Internal.Tip+                                                                                                                                                                else+                                                                                                                                                                  let _ = "choicesBranch.else"+                                                                                                                                                                   in Data.Map.Strict.Internal.findWithDefault finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure callerOnExceptionStackByLabel Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp farInp farExp+                                                                                                                                       in let _ = "pushValue"+                                                                                                                                           in let join = \farInp farExp v (!inp) ->+                                                                                                                                                    let _ = "lift2Value checkedHorizon=0"+                                                                                                                                                     in let _ = "commit"+                                                                                                                                                         in let _ = "resume"+                                                                                                                                                             in join+                                                                                                                                                                  farInp+                                                                                                                                                                  farExp+                                                                                                                                                                  ( let _ = "resume.genCode"+                                                                                                                                                                     in GHC.Tuple . ()+                                                                                                                                                                  )+                                                                                                                                                                  inp+                                                                                                                                               in let _ = "catch ExceptionFailure checkedHorizon=0"+                                                                                                                                                   in let onException =+                                                                                                                                                            let _ = "onException"+                                                                                                                                                             in \(!_exn) (!failInp) (!farInp) (!farExp) ->+                                                                                                                                                                  let _ = "comment: raiseAgainIfConsumed"+                                                                                                                                                                   in let _ = "saveInput checkedHorizon=0"+                                                                                                                                                                       in let _ = "lift2Value checkedHorizon=0"+                                                                                                                                                                           in if ( \( Data.Text.Internal.Text+                                                                                                                                                                                        _+                                                                                                                                                                                        i+                                                                                                                                                                                        _+                                                                                                                                                                                      )+                                                                                                                                                                                    ( Data.Text.Internal.Text+                                                                                                                                                                                        _+                                                                                                                                                                                        j+                                                                                                                                                                                        _+                                                                                                                                                                                      ) -> i GHC.Classes.== j+                                                                                                                                                                                 )+                                                                                                                                                                                inp+                                                                                                                                                                                failInp+                                                                                                                                                                                then+                                                                                                                                                                                  let _ = "choicesBranch checkedHorizon=0"+                                                                                                                                                                                   in name+                                                                                                                                                                                        ( let _ = "onReturn"+                                                                                                                                                                                           in \farInp farExp v (!inp) ->+                                                                                                                                                                                                let _ = "resume"+                                                                                                                                                                                                 in join+                                                                                                                                                                                                      farInp+                                                                                                                                                                                                      farExp+                                                                                                                                                                                                      ( let _ = "resume.genCode"+                                                                                                                                                                                                         in v+                                                                                                                                                                                                      )+                                                                                                                                                                                                      inp+                                                                                                                                                                                        )+                                                                                                                                                                                        failInp+                                                                                                                                                                                        (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure onException Data.Map.Internal.Tip Data.Map.Internal.Tip)+                                                                                                                                                                                else+                                                                                                                                                                                  let _ = "choicesBranch.else"+                                                                                                                                                                                   in onException Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp farInp farExp+                                                                                                                                                       in let _ = "pushValue"+                                                                                                                                                           in name+                                                                                                                                                                ( let _ = "onReturn"+                                                                                                                                                                   in \farInp farExp v (!inp) ->+                                                                                                                                                                        let _ = "lift2Value checkedHorizon=0"+                                                                                                                                                                         in let join = \farInp farExp v (!inp) ->+                                                                                                                                                                                  let _ = "lift2Value checkedHorizon=0"+                                                                                                                                                                                   in name+                                                                                                                                                                                        ( let _ = "onReturn"+                                                                                                                                                                                           in \farInp farExp v (!inp) ->+                                                                                                                                                                                                let _ = "lift2Value checkedHorizon=0"+                                                                                                                                                                                                 in let _ = "commit"+                                                                                                                                                                                                     in let _ = "resume"+                                                                                                                                                                                                         in join+                                                                                                                                                                                                              farInp+                                                                                                                                                                                                              farExp+                                                                                                                                                                                                              ( let _ = "resume.genCode"+                                                                                                                                                                                                                 in v+                                                                                                                                                                                                              )+                                                                                                                                                                                                              inp+                                                                                                                                                                                        )+                                                                                                                                                                                        inp+                                                                                                                                                                                        (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure onException Data.Map.Internal.Tip Data.Map.Internal.Tip)+                                                                                                                                                                             in let _ = "catch ExceptionFailure checkedHorizon=0"+                                                                                                                                                                                 in let onException =+                                                                                                                                                                                          let _ = "onException"+                                                                                                                                                                                           in \(!_exn) (!failInp) (!farInp) (!farExp) ->+                                                                                                                                                                                                let _ = "comment: raiseAgainIfConsumed"+                                                                                                                                                                                                 in let _ = "saveInput checkedHorizon=0"+                                                                                                                                                                                                     in let _ = "lift2Value checkedHorizon=0"+                                                                                                                                                                                                         in if ( \( Data.Text.Internal.Text+                                                                                                                                                                                                                      _+                                                                                                                                                                                                                      i+                                                                                                                                                                                                                      _+                                                                                                                                                                                                                    )+                                                                                                                                                                                                                  ( Data.Text.Internal.Text+                                                                                                                                                                                                                      _+                                                                                                                                                                                                                      j+                                                                                                                                                                                                                      _+                                                                                                                                                                                                                    ) -> i GHC.Classes.== j+                                                                                                                                                                                                               )+                                                                                                                                                                                                              inp+                                                                                                                                                                                                              failInp+                                                                                                                                                                                                              then+                                                                                                                                                                                                                let _ = "choicesBranch checkedHorizon=0"+                                                                                                                                                                                                                 in name+                                                                                                                                                                                                                      ( let _ = "onReturn"+                                                                                                                                                                                                                         in \farInp farExp v (!inp) ->+                                                                                                                                                                                                                              let _ = "resume"+                                                                                                                                                                                                                               in join+                                                                                                                                                                                                                                    farInp+                                                                                                                                                                                                                                    farExp+                                                                                                                                                                                                                                    ( let _ = "resume.genCode"+                                                                                                                                                                                                                                       in v+                                                                                                                                                                                                                                    )+                                                                                                                                                                                                                                    inp+                                                                                                                                                                                                                      )+                                                                                                                                                                                                                      failInp+                                                                                                                                                                                                                      Data.Map.Internal.Tip+                                                                                                                                                                                                              else+                                                                                                                                                                                                                let _ = "choicesBranch.else"+                                                                                                                                                                                                                 in onException Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp farInp farExp+                                                                                                                                                                                     in let _ = "pushValue"+                                                                                                                                                                                         in name+                                                                                                                                                                                              ( let _ = "onReturn"+                                                                                                                                                                                                 in \farInp farExp v (!inp) ->+                                                                                                                                                                                                      let _ = "lift2Value checkedHorizon=0"+                                                                                                                                                                                                       in let _ = "pushValue"+                                                                                                                                                                                                           in do+                                                                                                                                                                                                                let dupv = \x -> x+                                                                                                                                                                                                                reg <- GHC.STRef.newSTRef dupv+                                                                                                                                                                                                                let _ = "iter"+                                                                                                                                                                                                                 in let onException loopInput =+                                                                                                                                                                                                                          let _ = "onException"+                                                                                                                                                                                                                           in \(!_exn) (!failInp) (!farInp) (!farExp) ->+                                                                                                                                                                                                                                let _ = "comment: raiseAgainIfConsumed"+                                                                                                                                                                                                                                 in let _ = "saveInput checkedHorizon=0"+                                                                                                                                                                                                                                     in let _ = "lift2Value checkedHorizon=0"+                                                                                                                                                                                                                                         in if ( \( Data.Text.Internal.Text+                                                                                                                                                                                                                                                      _+                                                                                                                                                                                                                                                      i+                                                                                                                                                                                                                                                      _+                                                                                                                                                                                                                                                    )+                                                                                                                                                                                                                                                  ( Data.Text.Internal.Text+                                                                                                                                                                                                                                                      _+                                                                                                                                                                                                                                                      j+                                                                                                                                                                                                                                                      _+                                                                                                                                                                                                                                                    ) -> i GHC.Classes.== j+                                                                                                                                                                                                                                               )+                                                                                                                                                                                                                                              loopInput+                                                                                                                                                                                                                                              failInp+                                                                                                                                                                                                                                              then+                                                                                                                                                                                                                                                let _ = "choicesBranch checkedHorizon=0"+                                                                                                                                                                                                                                                 in do+                                                                                                                                                                                                                                                      sr <- GHC.STRef.readSTRef reg+                                                                                                                                                                                                                                                      name+                                                                                                                                                                                                                                                        ( let _ = "onReturn"+                                                                                                                                                                                                                                                           in \farInp farExp v (!inp) ->+                                                                                                                                                                                                                                                                let _ = "lift2Value checkedHorizon=0"+                                                                                                                                                                                                                                                                 in let _ = "lift2Value checkedHorizon=0"+                                                                                                                                                                                                                                                                     in name+                                                                                                                                                                                                                                                                          ( let _ = "onReturn"+                                                                                                                                                                                                                                                                             in \farInp farExp v (!inp) ->+                                                                                                                                                                                                                                                                                  let _ = "lift2Value checkedHorizon=0"+                                                                                                                                                                                                                                                                                   in let _ = "commit"+                                                                                                                                                                                                                                                                                       in let _ = "resume"+                                                                                                                                                                                                                                                                                           in join+                                                                                                                                                                                                                                                                                                farInp+                                                                                                                                                                                                                                                                                                farExp+                                                                                                                                                                                                                                                                                                ( let _ = "resume.genCode"+                                                                                                                                                                                                                                                                                                   in GHC.Tuple . ()+                                                                                                                                                                                                                                                                                                )+                                                                                                                                                                                                                                                                                                inp+                                                                                                                                                                                                                                                                          )+                                                                                                                                                                                                                                                                          inp+                                                                                                                                                                                                                                                                          Data.Map.Internal.Tip+                                                                                                                                                                                                                                                        )+                                                                                                                                                                                                                                                        failInp+                                                                                                                                                                                                                                                        Data.Map.Internal.Tip+                                                                                                                                                                                                                                              else+                                                                                                                                                                                                                                                let _ = "choicesBranch.else"+                                                                                                                                                                                                                                                 in onException Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp farInp farExp+                                                                                                                                                                                                                        loop = \_callerOnReturn callerInput callerOnExceptionStackByLabel ->+                                                                                                                                                                                                                          let _ = "pushValue"+                                                                                                                                                                                                                           in name+                                                                                                                                                                                                                                ( let _ = "onReturn"+                                                                                                                                                                                                                                   in \farInp farExp v (!inp) ->+                                                                                                                                                                                                                                        let _ = "lift2Value checkedHorizon=0"+                                                                                                                                                                                                                                         in name+                                                                                                                                                                                                                                              ( let _ = "onReturn"+                                                                                                                                                                                                                                                 in \farInp farExp v (!inp) ->+                                                                                                                                                                                                                                                      let _ = "lift2Value checkedHorizon=0"+                                                                                                                                                                                                                                                       in name+                                                                                                                                                                                                                                                            ( let _ = "onReturn"+                                                                                                                                                                                                                                                               in \farInp farExp v (!inp) ->+                                                                                                                                                                                                                                                                    let _ = "lift2Value checkedHorizon=0"+                                                                                                                                                                                                                                                                     in do+                                                                                                                                                                                                                                                                          sr <- GHC.STRef.readSTRef reg+                                                                                                                                                                                                                                                                          let _ = "lift2Value checkedHorizon=0"+                                                                                                                                                                                                                                                                           in do+                                                                                                                                                                                                                                                                                let dupv = v v sr+                                                                                                                                                                                                                                                                                GHC.STRef.writeSTRef reg dupv+                                                                                                                                                                                                                                                                                let _ = "jump"+                                                                                                                                                                                                                                                                                 in loop (GHC.Err.error "invalid onReturn") inp (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure (onException callerInput) Data.Map.Internal.Tip Data.Map.Internal.Tip)+                                                                                                                                                                                                                                                            )+                                                                                                                                                                                                                                                            inp+                                                                                                                                                                                                                                                            (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure (onException callerInput) Data.Map.Internal.Tip Data.Map.Internal.Tip)+                                                                                                                                                                                                                                              )+                                                                                                                                                                                                                                              inp+                                                                                                                                                                                                                                              (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure (onException callerInput) Data.Map.Internal.Tip Data.Map.Internal.Tip)+                                                                                                                                                                                                                                )+                                                                                                                                                                                                                                callerInput+                                                                                                                                                                                                                                Data.Map.Internal.Tip+                                                                                                                                                                                                                     in let _ = "jump"+                                                                                                                                                                                                                         in loop callerOnReturn inp (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure onException Data.Map.Internal.Tip Data.Map.Internal.Tip)+                                                                                                                                                                                              )+                                                                                                                                                                                              inp+                                                                                                                                                                                              (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure onException Data.Map.Internal.Tip Data.Map.Internal.Tip)+                                                                                                                                                                )+                                                                                                                                                                inp+                                                                                                                                                                (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure onException Data.Map.Internal.Tip Data.Map.Internal.Tip)+                                                                                                                  )+                                                                                                                  failInp+                                                                                                                  (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure (Data.Map.Strict.Internal.findWithDefault finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure callerOnExceptionStackByLabel) Data.Map.Internal.Tip Data.Map.Internal.Tip)+                                                                                                      else+                                                                                                        let _ = "choicesBranch.else"+                                                                                                         in Data.Map.Strict.Internal.findWithDefault finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure callerOnExceptionStackByLabel Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp farInp farExp+                                                                             in let _ = "pushValue"+                                                                                 in let _ = "comment: satisfy ((GHC.Classes.==) '\\'')"+                                                                                     in let inp = failInp+                                                                                         in let readFail = onException+                                                                                             in let _ = "checkHorizon.newCheck: checkedHorizon=0 minHoriz=4"+                                                                                                 in if readMore (Symantic.Parser.Machine.Input.shiftRightText 3 inp)+                                                                                                      then+                                                                                                        let _ = "checkToken"+                                                                                                         in let !(#+                                                                                                                   c,+                                                                                                                   cs+                                                                                                                   #) = readNext inp+                                                                                                             in if (GHC.Classes.==) '\'' c+                                                                                                                  then+                                                                                                                    let _ = "lift2Value checkedHorizon=4"+                                                                                                                     in let join = \farInp farExp v (!inp) ->+                                                                                                                              let _ = "lift2Value checkedHorizon=0"+                                                                                                                               in let _ = "comment: satisfy ((GHC.Classes.==) '\\'')"+                                                                                                                                   in let inp = inp+                                                                                                                                       in let readFail = readFail+                                                                                                                                           in let _ = "checkHorizon.newCheck: checkedHorizon=0 minHoriz=2"+                                                                                                                                               in if readMore (Symantic.Parser.Machine.Input.shiftRightText 1 inp)+                                                                                                                                                    then+                                                                                                                                                      let _ = "checkToken"+                                                                                                                                                       in let !(#+                                                                                                                                                                 c,+                                                                                                                                                                 cs+                                                                                                                                                                 #) = readNext inp+                                                                                                                                                           in if (GHC.Classes.==) '\'' c+                                                                                                                                                                then+                                                                                                                                                                  let _ = "lift2Value checkedHorizon=2"+                                                                                                                                                                   in name+                                                                                                                                                                        ( let _ = "onReturn"+                                                                                                                                                                           in \farInp farExp v (!inp) ->+                                                                                                                                                                                let _ = "lift2Value checkedHorizon=0"+                                                                                                                                                                                 in let _ = "commit"+                                                                                                                                                                                     in let _ = "resume"+                                                                                                                                                                                         in callerOnReturn+                                                                                                                                                                                              farInp+                                                                                                                                                                                              farExp+                                                                                                                                                                                              ( let _ = "resume.genCode"+                                                                                                                                                                                                 in v+                                                                                                                                                                                              )+                                                                                                                                                                                              inp+                                                                                                                                                                        )+                                                                                                                                                                        cs+                                                                                                                                                                        (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure readFail Data.Map.Internal.Tip Data.Map.Internal.Tip)+                                                                                                                                                                else+                                                                                                                                                                  let _ = "checkToken.fail"+                                                                                                                                                                   in let failExp =+                                                                                                                                                                            Data.Set.Internal.Bin+                                                                                                                                                                              1+                                                                                                                                                                              ( Symantic.Parser.Grammar.Combinators.SomeFailure+                                                                                                                                                                                  ( case inputToken of+                                                                                                                                                                                      (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken '\''+                                                                                                                                                                                  )+                                                                                                                                                                              )+                                                                                                                                                                              Data.Set.Internal.Tip+                                                                                                                                                                              Data.Set.Internal.Tip+                                                                                                                                                                       in let (#+                                                                                                                                                                                farInp,+                                                                                                                                                                                farExp+                                                                                                                                                                                #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp inp of+                                                                                                                                                                                  GHC.Types.LT ->+                                                                                                                                                                                    (#+                                                                                                                                                                                      inp,+                                                                                                                                                                                      failExp+                                                                                                                                                                                    #)+                                                                                                                                                                                  GHC.Types.EQ ->+                                                                                                                                                                                    (#+                                                                                                                                                                                      farInp,+                                                                                                                                                                                      failExp GHC.Base.<> farExp+                                                                                                                                                                                    #)+                                                                                                                                                                                  GHC.Types.GT ->+                                                                                                                                                                                    (#+                                                                                                                                                                                      farInp,+                                                                                                                                                                                      farExp+                                                                                                                                                                                    #)+                                                                                                                                                                           in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp+                                                                                                                                                    else+                                                                                                                                                      let _ = "checkHorizon.newCheck.fail"+                                                                                                                                                       in let failExp =+                                                                                                                                                                Data.Set.Internal.Bin+                                                                                                                                                                  1+                                                                                                                                                                  ( Symantic.Parser.Grammar.Combinators.SomeFailure+                                                                                                                                                                      ( case inputToken of+                                                                                                                                                                          (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureHorizon @tok' 2+                                                                                                                                                                      )+                                                                                                                                                                  )+                                                                                                                                                                  Data.Set.Internal.Tip+                                                                                                                                                                  Data.Set.Internal.Tip+                                                                                                                                                           in let (#+                                                                                                                                                                    farInp,+                                                                                                                                                                    farExp+                                                                                                                                                                    #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp inp of+                                                                                                                                                                      GHC.Types.LT ->+                                                                                                                                                                        (#+                                                                                                                                                                          inp,+                                                                                                                                                                          failExp+                                                                                                                                                                        #)+                                                                                                                                                                      GHC.Types.EQ ->+                                                                                                                                                                        (#+                                                                                                                                                                          farInp,+                                                                                                                                                                          failExp GHC.Base.<> farExp+                                                                                                                                                                        #)+                                                                                                                                                                      GHC.Types.GT ->+                                                                                                                                                                        (#+                                                                                                                                                                          farInp,+                                                                                                                                                                          farExp+                                                                                                                                                                        #)+                                                                                                                                                               in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp+                                                                                                                         in let _ = "catch ExceptionFailure checkedHorizon=4"+                                                                                                                             in let onException =+                                                                                                                                      let _ = "onException"+                                                                                                                                       in \(!_exn) (!failInp) (!farInp) (!farExp) ->+                                                                                                                                            let _ = "comment: raiseAgainIfConsumed"+                                                                                                                                             in let _ = "saveInput checkedHorizon=0"+                                                                                                                                                 in let _ = "lift2Value checkedHorizon=0"+                                                                                                                                                     in if ( \( Data.Text.Internal.Text+                                                                                                                                                                  _+                                                                                                                                                                  i+                                                                                                                                                                  _+                                                                                                                                                                )+                                                                                                                                                              ( Data.Text.Internal.Text+                                                                                                                                                                  _+                                                                                                                                                                  j+                                                                                                                                                                  _+                                                                                                                                                                ) -> i GHC.Classes.== j+                                                                                                                                                           )+                                                                                                                                                          cs+                                                                                                                                                          failInp+                                                                                                                                                          then+                                                                                                                                                            let _ = "choicesBranch checkedHorizon=0"+                                                                                                                                                             in let _ = "pushValue"+                                                                                                                                                                 in let _ = "comment: satisfy ((GHC.Classes.==) '\\\\')"+                                                                                                                                                                     in let inp = failInp+                                                                                                                                                                         in let readFail = readFail+                                                                                                                                                                             in let _ = "checkHorizon.newCheck: checkedHorizon=0 minHoriz=4"+                                                                                                                                                                                 in if readMore (Symantic.Parser.Machine.Input.shiftRightText 3 inp)+                                                                                                                                                                                      then+                                                                                                                                                                                        let _ = "checkToken"+                                                                                                                                                                                         in let !(#+                                                                                                                                                                                                   c,+                                                                                                                                                                                                   cs+                                                                                                                                                                                                   #) = readNext inp+                                                                                                                                                                                             in if (GHC.Classes.==) '\\' c+                                                                                                                                                                                                  then+                                                                                                                                                                                                    let _ = "lift2Value checkedHorizon=4"+                                                                                                                                                                                                     in let _ = "comment: satisfy (\\t_0 -> ('0' GHC.Classes.== t_0) GHC.Classes.|| (('t' GHC.Classes.== t_0) GHC.Classes.|| (('n' GHC.Classes.== t_0) GHC.Classes.|| (('v' GHC.Classes.== t_0) GHC.Classes.|| (('f' GHC.Classes.== t_0) GHC.Classes.|| (('r' GHC.Classes.== t_0) GHC.Classes.|| GHC.Types.False))))))"+                                                                                                                                                                                                         in let _ = "checkHorizon.oldCheck: checkedHorizon=4"+                                                                                                                                                                                                             in let _ = "checkToken"+                                                                                                                                                                                                                 in let !(#+                                                                                                                                                                                                                           c,+                                                                                                                                                                                                                           cs+                                                                                                                                                                                                                           #) = readNext cs+                                                                                                                                                                                                                     in if (\t -> ('0' GHC.Classes.== t) GHC.Classes.|| (('t' GHC.Classes.== t) GHC.Classes.|| (('n' GHC.Classes.== t) GHC.Classes.|| (('v' GHC.Classes.== t) GHC.Classes.|| (('f' GHC.Classes.== t) GHC.Classes.|| (('r' GHC.Classes.== t) GHC.Classes.|| GHC.Types.False)))))) c+                                                                                                                                                                                                                          then+                                                                                                                                                                                                                            let _ = "lift2Value checkedHorizon=3"+                                                                                                                                                                                                                             in name+                                                                                                                                                                                                                                  ( let _ = "onReturn"+                                                                                                                                                                                                                                     in \farInp farExp v (!inp) ->+                                                                                                                                                                                                                                          let _ = "lift2Value checkedHorizon=0"+                                                                                                                                                                                                                                           in let _ = "resume"+                                                                                                                                                                                                                                               in join+                                                                                                                                                                                                                                                    farInp+                                                                                                                                                                                                                                                    farExp+                                                                                                                                                                                                                                                    ( let _ = "resume.genCode"+                                                                                                                                                                                                                                                       in v+                                                                                                                                                                                                                                                    )+                                                                                                                                                                                                                                                    inp+                                                                                                                                                                                                                                  )+                                                                                                                                                                                                                                  cs+                                                                                                                                                                                                                                  Data.Map.Internal.Tip+                                                                                                                                                                                                                          else+                                                                                                                                                                                                                            let _ = "checkToken.fail"+                                                                                                                                                                                                                             in let failExp =+                                                                                                                                                                                                                                      Data.Set.Internal.Bin+                                                                                                                                                                                                                                        6+                                                                                                                                                                                                                                        ( Symantic.Parser.Grammar.Combinators.SomeFailure+                                                                                                                                                                                                                                            ( case inputToken of+                                                                                                                                                                                                                                                (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken 'n'+                                                                                                                                                                                                                                            )+                                                                                                                                                                                                                                        )+                                                                                                                                                                                                                                        ( Data.Set.Internal.Bin+                                                                                                                                                                                                                                            2+                                                                                                                                                                                                                                            ( Symantic.Parser.Grammar.Combinators.SomeFailure+                                                                                                                                                                                                                                                ( case inputToken of+                                                                                                                                                                                                                                                    (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken '0'+                                                                                                                                                                                                                                                )+                                                                                                                                                                                                                                            )+                                                                                                                                                                                                                                            Data.Set.Internal.Tip+                                                                                                                                                                                                                                            ( Data.Set.Internal.Bin+                                                                                                                                                                                                                                                1+                                                                                                                                                                                                                                                ( Symantic.Parser.Grammar.Combinators.SomeFailure+                                                                                                                                                                                                                                                    ( case inputToken of+                                                                                                                                                                                                                                                        (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken 'f'+                                                                                                                                                                                                                                                    )+                                                                                                                                                                                                                                                )+                                                                                                                                                                                                                                                Data.Set.Internal.Tip+                                                                                                                                                                                                                                                Data.Set.Internal.Tip+                                                                                                                                                                                                                                            )+                                                                                                                                                                                                                                        )+                                                                                                                                                                                                                                        ( Data.Set.Internal.Bin+                                                                                                                                                                                                                                            3+                                                                                                                                                                                                                                            ( Symantic.Parser.Grammar.Combinators.SomeFailure+                                                                                                                                                                                                                                                ( case inputToken of+                                                                                                                                                                                                                                                    (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken 't'+                                                                                                                                                                                                                                                )+                                                                                                                                                                                                                                            )+                                                                                                                                                                                                                                            ( Data.Set.Internal.Bin+                                                                                                                                                                                                                                                1+                                                                                                                                                                                                                                                ( Symantic.Parser.Grammar.Combinators.SomeFailure+                                                                                                                                                                                                                                                    ( case inputToken of+                                                                                                                                                                                                                                                        (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken 'r'+                                                                                                                                                                                                                                                    )+                                                                                                                                                                                                                                                )+                                                                                                                                                                                                                                                Data.Set.Internal.Tip+                                                                                                                                                                                                                                                Data.Set.Internal.Tip+                                                                                                                                                                                                                                            )+                                                                                                                                                                                                                                            ( Data.Set.Internal.Bin+                                                                                                                                                                                                                                                1+                                                                                                                                                                                                                                                ( Symantic.Parser.Grammar.Combinators.SomeFailure+                                                                                                                                                                                                                                                    ( case inputToken of+                                                                                                                                                                                                                                                        (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken 'v'+                                                                                                                                                                                                                                                    )+                                                                                                                                                                                                                                                )+                                                                                                                                                                                                                                                Data.Set.Internal.Tip+                                                                                                                                                                                                                                                Data.Set.Internal.Tip+                                                                                                                                                                                                                                            )+                                                                                                                                                                                                                                        )+                                                                                                                                                                                                                                 in let (#+                                                                                                                                                                                                                                          farInp,+                                                                                                                                                                                                                                          farExp+                                                                                                                                                                                                                                          #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp cs of+                                                                                                                                                                                                                                            GHC.Types.LT ->+                                                                                                                                                                                                                                              (#+                                                                                                                                                                                                                                                cs,+                                                                                                                                                                                                                                                failExp+                                                                                                                                                                                                                                              #)+                                                                                                                                                                                                                                            GHC.Types.EQ ->+                                                                                                                                                                                                                                              (#+                                                                                                                                                                                                                                                farInp,+                                                                                                                                                                                                                                                failExp GHC.Base.<> farExp+                                                                                                                                                                                                                                              #)+                                                                                                                                                                                                                                            GHC.Types.GT ->+                                                                                                                                                                                                                                              (#+                                                                                                                                                                                                                                                farInp,+                                                                                                                                                                                                                                                farExp+                                                                                                                                                                                                                                              #)+                                                                                                                                                                                                                                     in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure cs farInp farExp+                                                                                                                                                                                                  else+                                                                                                                                                                                                    let _ = "checkToken.fail"+                                                                                                                                                                                                     in let failExp =+                                                                                                                                                                                                              Data.Set.Internal.Bin+                                                                                                                                                                                                                1+                                                                                                                                                                                                                ( Symantic.Parser.Grammar.Combinators.SomeFailure+                                                                                                                                                                                                                    ( case inputToken of+                                                                                                                                                                                                                        (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken '\\'+                                                                                                                                                                                                                    )+                                                                                                                                                                                                                )+                                                                                                                                                                                                                Data.Set.Internal.Tip+                                                                                                                                                                                                                Data.Set.Internal.Tip+                                                                                                                                                                                                         in let (#+                                                                                                                                                                                                                  farInp,+                                                                                                                                                                                                                  farExp+                                                                                                                                                                                                                  #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp inp of+                                                                                                                                                                                                                    GHC.Types.LT ->+                                                                                                                                                                                                                      (#+                                                                                                                                                                                                                        inp,+                                                                                                                                                                                                                        failExp+                                                                                                                                                                                                                      #)+                                                                                                                                                                                                                    GHC.Types.EQ ->+                                                                                                                                                                                                                      (#+                                                                                                                                                                                                                        farInp,+                                                                                                                                                                                                                        failExp GHC.Base.<> farExp+                                                                                                                                                                                                                      #)+                                                                                                                                                                                                                    GHC.Types.GT ->+                                                                                                                                                                                                                      (#+                                                                                                                                                                                                                        farInp,+                                                                                                                                                                                                                        farExp+                                                                                                                                                                                                                      #)+                                                                                                                                                                                                             in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp+                                                                                                                                                                                      else+                                                                                                                                                                                        let _ = "checkHorizon.newCheck.fail"+                                                                                                                                                                                         in let failExp =+                                                                                                                                                                                                  Data.Set.Internal.Bin+                                                                                                                                                                                                    1+                                                                                                                                                                                                    ( Symantic.Parser.Grammar.Combinators.SomeFailure+                                                                                                                                                                                                        ( case inputToken of+                                                                                                                                                                                                            (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureHorizon @tok' 4+                                                                                                                                                                                                        )+                                                                                                                                                                                                    )+                                                                                                                                                                                                    Data.Set.Internal.Tip+                                                                                                                                                                                                    Data.Set.Internal.Tip+                                                                                                                                                                                             in let (#+                                                                                                                                                                                                      farInp,+                                                                                                                                                                                                      farExp+                                                                                                                                                                                                      #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp inp of+                                                                                                                                                                                                        GHC.Types.LT ->+                                                                                                                                                                                                          (#+                                                                                                                                                                                                            inp,+                                                                                                                                                                                                            failExp+                                                                                                                                                                                                          #)+                                                                                                                                                                                                        GHC.Types.EQ ->+                                                                                                                                                                                                          (#+                                                                                                                                                                                                            farInp,+                                                                                                                                                                                                            failExp GHC.Base.<> farExp+                                                                                                                                                                                                          #)+                                                                                                                                                                                                        GHC.Types.GT ->+                                                                                                                                                                                                          (#+                                                                                                                                                                                                            farInp,+                                                                                                                                                                                                            farExp+                                                                                                                                                                                                          #)+                                                                                                                                                                                                 in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp+                                                                                                                                                          else+                                                                                                                                                            let _ = "choicesBranch.else"+                                                                                                                                                             in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp farInp farExp+                                                                                                                                 in let _ = "pushValue"+                                                                                                                                     in let _ = "comment: satisfy Parsers.Nandlang.nandStringLetter"+                                                                                                                                         in let _ = "checkHorizon.oldCheck: checkedHorizon=4"+                                                                                                                                             in let _ = "checkToken"+                                                                                                                                                 in let !(#+                                                                                                                                                           c,+                                                                                                                                                           cs+                                                                                                                                                           #) = readNext cs+                                                                                                                                                     in if Parsers.Nandlang.nandStringLetter c+                                                                                                                                                          then+                                                                                                                                                            let _ = "lift2Value checkedHorizon=3"+                                                                                                                                                             in name+                                                                                                                                                                  ( let _ = "onReturn"+                                                                                                                                                                     in \farInp farExp v (!inp) ->+                                                                                                                                                                          let _ = "lift2Value checkedHorizon=0"+                                                                                                                                                                           in let _ = "commit"+                                                                                                                                                                               in let _ = "resume"+                                                                                                                                                                                   in join+                                                                                                                                                                                        farInp+                                                                                                                                                                                        farExp+                                                                                                                                                                                        ( let _ = "resume.genCode"+                                                                                                                                                                                           in v+                                                                                                                                                                                        )+                                                                                                                                                                                        inp+                                                                                                                                                                  )+                                                                                                                                                                  cs+                                                                                                                                                                  Data.Map.Internal.Tip+                                                                                                                                                          else+                                                                                                                                                            let _ = "checkToken.fail"+                                                                                                                                                             in onException Symantic.Parser.Grammar.Combinators.ExceptionFailure cs farInp farExp+                                                                                                                  else+                                                                                                                    let _ = "checkToken.fail"+                                                                                                                     in let failExp =+                                                                                                                              Data.Set.Internal.Bin+                                                                                                                                1+                                                                                                                                ( Symantic.Parser.Grammar.Combinators.SomeFailure+                                                                                                                                    ( case inputToken of+                                                                                                                                        (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken '\''+                                                                                                                                    )+                                                                                                                                )+                                                                                                                                Data.Set.Internal.Tip+                                                                                                                                Data.Set.Internal.Tip+                                                                                                                         in let (#+                                                                                                                                  farInp,+                                                                                                                                  farExp+                                                                                                                                  #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp inp of+                                                                                                                                    GHC.Types.LT ->+                                                                                                                                      (#+                                                                                                                                        inp,+                                                                                                                                        failExp+                                                                                                                                      #)+                                                                                                                                    GHC.Types.EQ ->+                                                                                                                                      (#+                                                                                                                                        farInp,+                                                                                                                                        failExp GHC.Base.<> farExp+                                                                                                                                      #)+                                                                                                                                    GHC.Types.GT ->+                                                                                                                                      (#+                                                                                                                                        farInp,+                                                                                                                                        farExp+                                                                                                                                      #)+                                                                                                                             in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp+                                                                                                      else+                                                                                                        let _ = "checkHorizon.newCheck.fail"+                                                                                                         in let failExp =+                                                                                                                  Data.Set.Internal.Bin+                                                                                                                    1+                                                                                                                    ( Symantic.Parser.Grammar.Combinators.SomeFailure+                                                                                                                        ( case inputToken of+                                                                                                                            (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureHorizon @tok' 4+                                                                                                                        )+                                                                                                                    )+                                                                                                                    Data.Set.Internal.Tip+                                                                                                                    Data.Set.Internal.Tip+                                                                                                             in let (#+                                                                                                                      farInp,+                                                                                                                      farExp+                                                                                                                      #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp inp of+                                                                                                                        GHC.Types.LT ->+                                                                                                                          (#+                                                                                                                            inp,+                                                                                                                            failExp+                                                                                                                          #)+                                                                                                                        GHC.Types.EQ ->+                                                                                                                          (#+                                                                                                                            farInp,+                                                                                                                            failExp GHC.Base.<> farExp+                                                                                                                          #)+                                                                                                                        GHC.Types.GT ->+                                                                                                                          (#+                                                                                                                            farInp,+                                                                                                                            farExp+                                                                                                                          #)+                                                                                                                 in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp+                                                                  else+                                                                    let _ = "choicesBranch.else"+                                                                     in Data.Map.Strict.Internal.findWithDefault finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure callerOnExceptionStackByLabel Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp farInp farExp+                                         in let _ = "pushValue"+                                             in let join = \farInp farExp v (!inp) ->+                                                      let _ = "lift2Value checkedHorizon=0"+                                                       in name+                                                            ( let _ = "onReturn"+                                                               in \farInp farExp v (!inp) ->+                                                                    let _ = "lift2Value checkedHorizon=0"+                                                                     in let _ = "commit"+                                                                         in let _ = "resume"+                                                                             in callerOnReturn+                                                                                  farInp+                                                                                  farExp+                                                                                  ( let _ = "resume.genCode"+                                                                                     in v+                                                                                  )+                                                                                  inp+                                                            )+                                                            inp+                                                            (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure onException Data.Map.Internal.Tip Data.Map.Internal.Tip)+                                                 in let _ = "catch ExceptionFailure checkedHorizon=0"+                                                     in let onException =+                                                              let _ = "onException"+                                                               in \(!_exn) (!failInp) (!farInp) (!farExp) ->+                                                                    let _ = "comment: raiseAgainIfConsumed"+                                                                     in let _ = "saveInput checkedHorizon=0"+                                                                         in let _ = "lift2Value checkedHorizon=0"+                                                                             in if ( \( Data.Text.Internal.Text+                                                                                          _+                                                                                          i+                                                                                          _+                                                                                        )+                                                                                      ( Data.Text.Internal.Text+                                                                                          _+                                                                                          j+                                                                                          _+                                                                                        ) -> i GHC.Classes.== j+                                                                                   )+                                                                                  callerInput+                                                                                  failInp+                                                                                  then+                                                                                    let _ = "choicesBranch checkedHorizon=0"+                                                                                     in let _ = "pushValue"+                                                                                         in let _ = "comment: satisfy ((GHC.Classes.==) '1')"+                                                                                             in let inp = failInp+                                                                                                 in let readFail = onException+                                                                                                     in let _ = "checkHorizon.newCheck: checkedHorizon=0 minHoriz=2"+                                                                                                         in if readMore (Symantic.Parser.Machine.Input.shiftRightText 1 inp)+                                                                                                              then+                                                                                                                let _ = "checkToken"+                                                                                                                 in let !(#+                                                                                                                           c,+                                                                                                                           cs+                                                                                                                           #) = readNext inp+                                                                                                                     in if (GHC.Classes.==) '1' c+                                                                                                                          then+                                                                                                                            let _ = "lift2Value checkedHorizon=2"+                                                                                                                             in let _ = "resume"+                                                                                                                                 in join+                                                                                                                                      farInp+                                                                                                                                      farExp+                                                                                                                                      ( let _ = "resume.genCode"+                                                                                                                                         in '1'+                                                                                                                                      )+                                                                                                                                      cs+                                                                                                                          else+                                                                                                                            let _ = "checkToken.fail"+                                                                                                                             in let failExp =+                                                                                                                                      Data.Set.Internal.Bin+                                                                                                                                        1+                                                                                                                                        ( Symantic.Parser.Grammar.Combinators.SomeFailure+                                                                                                                                            ( case inputToken of+                                                                                                                                                (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken '1'+                                                                                                                                            )+                                                                                                                                        )+                                                                                                                                        Data.Set.Internal.Tip+                                                                                                                                        Data.Set.Internal.Tip+                                                                                                                                 in let (#+                                                                                                                                          farInp,+                                                                                                                                          farExp+                                                                                                                                          #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp inp of+                                                                                                                                            GHC.Types.LT ->+                                                                                                                                              (#+                                                                                                                                                inp,+                                                                                                                                                failExp+                                                                                                                                              #)+                                                                                                                                            GHC.Types.EQ ->+                                                                                                                                              (#+                                                                                                                                                farInp,+                                                                                                                                                failExp GHC.Base.<> farExp+                                                                                                                                              #)+                                                                                                                                            GHC.Types.GT ->+                                                                                                                                              (#+                                                                                                                                                farInp,+                                                                                                                                                farExp+                                                                                                                                              #)+                                                                                                                                     in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp+                                                                                                              else+                                                                                                                let _ = "checkHorizon.newCheck.fail"+                                                                                                                 in let failExp =+                                                                                                                          Data.Set.Internal.Bin+                                                                                                                            1+                                                                                                                            ( Symantic.Parser.Grammar.Combinators.SomeFailure+                                                                                                                                ( case inputToken of+                                                                                                                                    (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureHorizon @tok' 2+                                                                                                                                )+                                                                                                                            )+                                                                                                                            Data.Set.Internal.Tip+                                                                                                                            Data.Set.Internal.Tip+                                                                                                                     in let (#+                                                                                                                              farInp,+                                                                                                                              farExp+                                                                                                                              #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp inp of+                                                                                                                                GHC.Types.LT ->+                                                                                                                                  (#+                                                                                                                                    inp,+                                                                                                                                    failExp+                                                                                                                                  #)+                                                                                                                                GHC.Types.EQ ->+                                                                                                                                  (#+                                                                                                                                    farInp,+                                                                                                                                    failExp GHC.Base.<> farExp+                                                                                                                                  #)+                                                                                                                                GHC.Types.GT ->+                                                                                                                                  (#+                                                                                                                                    farInp,+                                                                                                                                    farExp+                                                                                                                                  #)+                                                                                                                         in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp+                                                                                  else+                                                                                    let _ = "choicesBranch.else"+                                                                                     in onException Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp farInp farExp+                                                         in let _ = "pushValue"+                                                             in let _ = "comment: satisfy ((GHC.Classes.==) '0')"+                                                                 in let inp = callerInput+                                                                     in let readFail = onException+                                                                         in let _ = "checkHorizon.newCheck: checkedHorizon=0 minHoriz=2"+                                                                             in if readMore (Symantic.Parser.Machine.Input.shiftRightText 1 inp)+                                                                                  then+                                                                                    let _ = "checkToken"+                                                                                     in let !(#+                                                                                               c,+                                                                                               cs+                                                                                               #) = readNext inp+                                                                                         in if (GHC.Classes.==) '0' c+                                                                                              then+                                                                                                let _ = "lift2Value checkedHorizon=2"+                                                                                                 in let _ = "commit"+                                                                                                     in let _ = "resume"+                                                                                                         in join+                                                                                                              init+                                                                                                              Data.Set.Internal.empty+                                                                                                              ( let _ = "resume.genCode"+                                                                                                                 in '0'+                                                                                                              )+                                                                                                              cs+                                                                                              else+                                                                                                let _ = "checkToken.fail"+                                                                                                 in let failExp =+                                                                                                          Data.Set.Internal.Bin+                                                                                                            1+                                                                                                            ( Symantic.Parser.Grammar.Combinators.SomeFailure+                                                                                                                ( case inputToken of+                                                                                                                    (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken '0'+                                                                                                                )+                                                                                                            )+                                                                                                            Data.Set.Internal.Tip+                                                                                                            Data.Set.Internal.Tip+                                                                                                     in let (#+                                                                                                              farInp,+                                                                                                              farExp+                                                                                                              #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init inp of+                                                                                                                GHC.Types.LT ->+                                                                                                                  (#+                                                                                                                    inp,+                                                                                                                    failExp+                                                                                                                  #)+                                                                                                                GHC.Types.EQ ->+                                                                                                                  (#+                                                                                                                    init,+                                                                                                                    failExp GHC.Base.<> Data.Set.Internal.empty+                                                                                                                  #)+                                                                                                                GHC.Types.GT ->+                                                                                                                  (#+                                                                                                                    init,+                                                                                                                    Data.Set.Internal.empty+                                                                                                                  #)+                                                                                                         in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp+                                                                                  else+                                                                                    let _ = "checkHorizon.newCheck.fail"+                                                                                     in let failExp =+                                                                                              Data.Set.Internal.Bin+                                                                                                1+                                                                                                ( Symantic.Parser.Grammar.Combinators.SomeFailure+                                                                                                    ( case inputToken of+                                                                                                        (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureHorizon @tok' 2+                                                                                                    )+                                                                                                )+                                                                                                Data.Set.Internal.Tip+                                                                                                Data.Set.Internal.Tip+                                                                                         in let (#+                                                                                                  farInp,+                                                                                                  farExp+                                                                                                  #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init inp of+                                                                                                    GHC.Types.LT ->+                                                                                                      (#+                                                                                                        inp,+                                                                                                        failExp+                                                                                                      #)+                                                                                                    GHC.Types.EQ ->+                                                                                                      (#+                                                                                                        init,+                                                                                                        failExp GHC.Base.<> Data.Set.Internal.empty+                                                                                                      #)+                                                                                                    GHC.Types.GT ->+                                                                                                      (#+                                                                                                        init,+                                                                                                        Data.Set.Internal.empty+                                                                                                      #)+                                                                                             in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp+                                  name = \(!callerOnReturn) (!callerInput) (!callerOnExceptionStackByLabel) ->+                                    let _ = "catch ExceptionFailure checkedHorizon=0"+                                     in let onException =+                                              let _ = "onException"+                                               in \(!_exn) (!failInp) (!farInp) (!farExp) ->+                                                    let _ = "comment: raiseAgainIfConsumed"+                                                     in let _ = "saveInput checkedHorizon=0"+                                                         in let _ = "lift2Value checkedHorizon=0"+                                                             in if ( \( Data.Text.Internal.Text+                                                                          _+                                                                          i+                                                                          _+                                                                        )+                                                                      ( Data.Text.Internal.Text+                                                                          _+                                                                          j+                                                                          _+                                                                        ) -> i GHC.Classes.== j+                                                                   )+                                                                  callerInput+                                                                  failInp+                                                                  then+                                                                    let _ = "choicesBranch checkedHorizon=0"+                                                                     in let _ = "jump"+                                                                         in name callerOnReturn failInp Data.Map.Internal.Tip+                                                                  else+                                                                    let _ = "choicesBranch.else"+                                                                     in Data.Map.Strict.Internal.findWithDefault finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure callerOnExceptionStackByLabel Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp farInp farExp+                                         in let _ = "pushValue"+                                             in name+                                                  ( let _ = "onReturn"+                                                     in \farInp farExp v (!inp) ->+                                                          let _ = "lift2Value checkedHorizon=0"+                                                           in let _ = "pushValue"+                                                               in do+                                                                    let dupv = \x -> x+                                                                    reg <- GHC.STRef.newSTRef dupv+                                                                    let _ = "iter"+                                                                     in let onException loopInput =+                                                                              let _ = "onException"+                                                                               in \(!_exn) (!failInp) (!farInp) (!farExp) ->+                                                                                    let _ = "comment: raiseAgainIfConsumed"+                                                                                     in let _ = "saveInput checkedHorizon=0"+                                                                                         in let _ = "lift2Value checkedHorizon=0"+                                                                                             in if ( \( Data.Text.Internal.Text+                                                                                                          _+                                                                                                          i+                                                                                                          _+                                                                                                        )+                                                                                                      ( Data.Text.Internal.Text+                                                                                                          _+                                                                                                          j+                                                                                                          _+                                                                                                        ) -> i GHC.Classes.== j+                                                                                                   )+                                                                                                  loopInput+                                                                                                  failInp+                                                                                                  then+                                                                                                    let _ = "choicesBranch checkedHorizon=0"+                                                                                                     in do+                                                                                                          sr <- GHC.STRef.readSTRef reg+                                                                                                          name+                                                                                                            ( let _ = "onReturn"+                                                                                                               in \farInp farExp v (!inp) ->+                                                                                                                    let _ = "lift2Value checkedHorizon=0"+                                                                                                                     in let _ = "lift2Value checkedHorizon=0"+                                                                                                                         in name+                                                                                                                              ( let _ = "onReturn"+                                                                                                                                 in \farInp farExp v (!inp) ->+                                                                                                                                      let _ = "lift2Value checkedHorizon=0"+                                                                                                                                       in let _ = "commit"+                                                                                                                                           in let _ = "resume"+                                                                                                                                               in callerOnReturn+                                                                                                                                                    farInp+                                                                                                                                                    farExp+                                                                                                                                                    ( let _ = "resume.genCode"+                                                                                                                                                       in GHC.Tuple . ()+                                                                                                                                                    )+                                                                                                                                                    inp+                                                                                                                              )+                                                                                                                              inp+                                                                                                                              Data.Map.Internal.Tip+                                                                                                            )+                                                                                                            failInp+                                                                                                            Data.Map.Internal.Tip+                                                                                                  else+                                                                                                    let _ = "choicesBranch.else"+                                                                                                     in onException Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp farInp farExp+                                                                            loop = \_callerOnReturn callerInput callerOnExceptionStackByLabel ->+                                                                              let _ = "pushValue"+                                                                               in name+                                                                                    ( let _ = "onReturn"+                                                                                       in \farInp farExp v (!inp) ->+                                                                                            let _ = "lift2Value checkedHorizon=0"+                                                                                             in name+                                                                                                  ( let _ = "onReturn"+                                                                                                     in \farInp farExp v (!inp) ->+                                                                                                          let _ = "lift2Value checkedHorizon=0"+                                                                                                           in name+                                                                                                                ( let _ = "onReturn"+                                                                                                                   in \farInp farExp v (!inp) ->+                                                                                                                        let _ = "lift2Value checkedHorizon=0"+                                                                                                                         in do+                                                                                                                              sr <- GHC.STRef.readSTRef reg+                                                                                                                              let _ = "lift2Value checkedHorizon=0"+                                                                                                                               in do+                                                                                                                                    let dupv = v v sr+                                                                                                                                    GHC.STRef.writeSTRef reg dupv+                                                                                                                                    let _ = "jump"+                                                                                                                                     in loop (GHC.Err.error "invalid onReturn") inp (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure (onException callerInput) Data.Map.Internal.Tip Data.Map.Internal.Tip)+                                                                                                                )+                                                                                                                inp+                                                                                                                (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure (onException callerInput) Data.Map.Internal.Tip Data.Map.Internal.Tip)+                                                                                                  )+                                                                                                  inp+                                                                                                  (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure (onException callerInput) Data.Map.Internal.Tip Data.Map.Internal.Tip)+                                                                                    )+                                                                                    callerInput+                                                                                    Data.Map.Internal.Tip+                                                                         in let _ = "jump"+                                                                             in loop callerOnReturn inp (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure onException Data.Map.Internal.Tip Data.Map.Internal.Tip)+                                                  )+                                                  callerInput+                                                  (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure onException Data.Map.Internal.Tip Data.Map.Internal.Tip)+                                  name = \(!callerOnReturn) (!callerInput) (!callerOnExceptionStackByLabel) ->+                                    let _ = "comment: satisfy (\\t_0 -> ('0' GHC.Classes.== t_0) GHC.Classes.|| (('1' GHC.Classes.== t_0) GHC.Classes.|| (('2' GHC.Classes.== t_0) GHC.Classes.|| (('3' GHC.Classes.== t_0) GHC.Classes.|| (('4' GHC.Classes.== t_0) GHC.Classes.|| (('5' GHC.Classes.== t_0) GHC.Classes.|| (('6' GHC.Classes.== t_0) GHC.Classes.|| (('7' GHC.Classes.== t_0) GHC.Classes.|| (('8' GHC.Classes.== t_0) GHC.Classes.|| (('9' GHC.Classes.== t_0) GHC.Classes.|| GHC.Types.False))))))))))"+                                     in let inp = callerInput+                                         in let readFail = Data.Map.Strict.Internal.findWithDefault finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure callerOnExceptionStackByLabel+                                             in let _ = "checkHorizon.newCheck: checkedHorizon=0 minHoriz=1"+                                                 in if readMore inp+                                                      then+                                                        let _ = "checkToken"+                                                         in let !(#+                                                                   c,+                                                                   cs+                                                                   #) = readNext inp+                                                             in if (\t -> ('0' GHC.Classes.== t) GHC.Classes.|| (('1' GHC.Classes.== t) GHC.Classes.|| (('2' GHC.Classes.== t) GHC.Classes.|| (('3' GHC.Classes.== t) GHC.Classes.|| (('4' GHC.Classes.== t) GHC.Classes.|| (('5' GHC.Classes.== t) GHC.Classes.|| (('6' GHC.Classes.== t) GHC.Classes.|| (('7' GHC.Classes.== t) GHC.Classes.|| (('8' GHC.Classes.== t) GHC.Classes.|| (('9' GHC.Classes.== t) GHC.Classes.|| GHC.Types.False)))))))))) c+                                                                  then+                                                                    let _ = "resume"+                                                                     in callerOnReturn+                                                                          init+                                                                          Data.Set.Internal.empty+                                                                          ( let _ = "resume.genCode"+                                                                             in c+                                                                          )+                                                                          cs+                                                                  else+                                                                    let _ = "checkToken.fail"+                                                                     in let failExp =+                                                                              Data.Set.Internal.Bin+                                                                                10+                                                                                ( Symantic.Parser.Grammar.Combinators.SomeFailure+                                                                                    ( case inputToken of+                                                                                        (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken '3'+                                                                                    )+                                                                                )+                                                                                ( Data.Set.Internal.Bin+                                                                                    3+                                                                                    ( Symantic.Parser.Grammar.Combinators.SomeFailure+                                                                                        ( case inputToken of+                                                                                            (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken '1'+                                                                                        )+                                                                                    )+                                                                                    ( Data.Set.Internal.Bin+                                                                                        1+                                                                                        ( Symantic.Parser.Grammar.Combinators.SomeFailure+                                                                                            ( case inputToken of+                                                                                                (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken '0'+                                                                                            )+                                                                                        )+                                                                                        Data.Set.Internal.Tip+                                                                                        Data.Set.Internal.Tip+                                                                                    )+                                                                                    ( Data.Set.Internal.Bin+                                                                                        1+                                                                                        ( Symantic.Parser.Grammar.Combinators.SomeFailure+                                                                                            ( case inputToken of+                                                                                                (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken '2'+                                                                                            )+                                                                                        )+                                                                                        Data.Set.Internal.Tip+                                                                                        Data.Set.Internal.Tip+                                                                                    )+                                                                                )+                                                                                ( Data.Set.Internal.Bin+                                                                                    6+                                                                                    ( Symantic.Parser.Grammar.Combinators.SomeFailure+                                                                                        ( case inputToken of+                                                                                            (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken '7'+                                                                                        )+                                                                                    )+                                                                                    ( Data.Set.Internal.Bin+                                                                                        3+                                                                                        ( Symantic.Parser.Grammar.Combinators.SomeFailure+                                                                                            ( case inputToken of+                                                                                                (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken '5'+                                                                                            )+                                                                                        )+                                                                                        ( Data.Set.Internal.Bin+                                                                                            1+                                                                                            ( Symantic.Parser.Grammar.Combinators.SomeFailure+                                                                                                ( case inputToken of+                                                                                                    (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken '4'+                                                                                                )+                                                                                            )+                                                                                            Data.Set.Internal.Tip+                                                                                            Data.Set.Internal.Tip+                                                                                        )+                                                                                        ( Data.Set.Internal.Bin+                                                                                            1+                                                                                            ( Symantic.Parser.Grammar.Combinators.SomeFailure+                                                                                                ( case inputToken of+                                                                                                    (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken '6'+                                                                                                )+                                                                                            )+                                                                                            Data.Set.Internal.Tip+                                                                                            Data.Set.Internal.Tip+                                                                                        )+                                                                                    )+                                                                                    ( Data.Set.Internal.Bin+                                                                                        2+                                                                                        ( Symantic.Parser.Grammar.Combinators.SomeFailure+                                                                                            ( case inputToken of+                                                                                                (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken '8'+                                                                                            )+                                                                                        )+                                                                                        Data.Set.Internal.Tip+                                                                                        ( Data.Set.Internal.Bin+                                                                                            1+                                                                                            ( Symantic.Parser.Grammar.Combinators.SomeFailure+                                                                                                ( case inputToken of+                                                                                                    (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken '9'+                                                                                                )+                                                                                            )+                                                                                            Data.Set.Internal.Tip+                                                                                            Data.Set.Internal.Tip+                                                                                        )+                                                                                    )+                                                                                )+                                                                         in let (#+                                                                                  farInp,+                                                                                  farExp+                                                                                  #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init inp of+                                                                                    GHC.Types.LT ->+                                                                                      (#+                                                                                        inp,+                                                                                        failExp+                                                                                      #)+                                                                                    GHC.Types.EQ ->+                                                                                      (#+                                                                                        init,+                                                                                        failExp GHC.Base.<> Data.Set.Internal.empty+                                                                                      #)+                                                                                    GHC.Types.GT ->+                                                                                      (#+                                                                                        init,+                                                                                        Data.Set.Internal.empty+                                                                                      #)+                                                                             in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp+                                                      else+                                                        let _ = "checkHorizon.newCheck.fail"+                                                         in let failExp =+                                                                  Data.Set.Internal.Bin+                                                                    1+                                                                    ( Symantic.Parser.Grammar.Combinators.SomeFailure+                                                                        ( case inputToken of+                                                                            (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureHorizon @tok' 1+                                                                        )+                                                                    )+                                                                    Data.Set.Internal.Tip+                                                                    Data.Set.Internal.Tip+                                                             in let (#+                                                                      farInp,+                                                                      farExp+                                                                      #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init inp of+                                                                        GHC.Types.LT ->+                                                                          (#+                                                                            inp,+                                                                            failExp+                                                                          #)+                                                                        GHC.Types.EQ ->+                                                                          (#+                                                                            init,+                                                                            failExp GHC.Base.<> Data.Set.Internal.empty+                                                                          #)+                                                                        GHC.Types.GT ->+                                                                          (#+                                                                            init,+                                                                            Data.Set.Internal.empty+                                                                          #)+                                                                 in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp+                                  name = \(!callerOnReturn) (!callerInput) (!callerOnExceptionStackByLabel) ->+                                    let _ = "pushValue"+                                     in name+                                          ( let _ = "onReturn"+                                             in \farInp farExp v (!inp) ->+                                                  let _ = "lift2Value checkedHorizon=0"+                                                   in let join = \farInp farExp v (!inp) ->+                                                            let _ = "lift2Value checkedHorizon=0"+                                                             in let _ = "resume"+                                                                 in callerOnReturn+                                                                      farInp+                                                                      farExp+                                                                      ( let _ = "resume.genCode"+                                                                         in v+                                                                      )+                                                                      inp+                                                       in let _ = "catch ExceptionFailure checkedHorizon=0"+                                                           in let onException =+                                                                    let _ = "onException"+                                                                     in \(!_exn) (!failInp) (!farInp) (!farExp) ->+                                                                          let _ = "comment: raiseAgainIfConsumed"+                                                                           in let _ = "saveInput checkedHorizon=0"+                                                                               in let _ = "lift2Value checkedHorizon=0"+                                                                                   in if ( \( Data.Text.Internal.Text+                                                                                                _+                                                                                                i+                                                                                                _+                                                                                              )+                                                                                            ( Data.Text.Internal.Text+                                                                                                _+                                                                                                j+                                                                                                _+                                                                                              ) -> i GHC.Classes.== j+                                                                                         )+                                                                                        inp+                                                                                        failInp+                                                                                        then+                                                                                          let _ = "choicesBranch checkedHorizon=0"+                                                                                           in name+                                                                                                ( let _ = "onReturn"+                                                                                                   in \farInp farExp v (!inp) ->+                                                                                                        let _ = "resume"+                                                                                                         in join+                                                                                                              farInp+                                                                                                              farExp+                                                                                                              ( let _ = "resume.genCode"+                                                                                                                 in v+                                                                                                              )+                                                                                                              inp+                                                                                                )+                                                                                                failInp+                                                                                                Data.Map.Internal.Tip+                                                                                        else+                                                                                          let _ = "choicesBranch.else"+                                                                                           in Data.Map.Strict.Internal.findWithDefault finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure callerOnExceptionStackByLabel Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp farInp farExp+                                                               in let _ = "pushValue"+                                                                   in name+                                                                        ( let _ = "onReturn"+                                                                           in \farInp farExp v (!inp) ->+                                                                                let _ = "lift2Value checkedHorizon=0"+                                                                                 in let _ = "commit"+                                                                                     in let _ = "resume"+                                                                                         in join+                                                                                              farInp+                                                                                              farExp+                                                                                              ( let _ = "resume.genCode"+                                                                                                 in GHC.Tuple . ()+                                                                                              )+                                                                                              inp+                                                                        )+                                                                        inp+                                                                        (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure onException Data.Map.Internal.Tip Data.Map.Internal.Tip)+                                          )+                                          callerInput+                                          (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure (Data.Map.Strict.Internal.findWithDefault finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure callerOnExceptionStackByLabel) Data.Map.Internal.Tip Data.Map.Internal.Tip)+                                  name = \(!callerOnReturn) (!callerInput) (!callerOnExceptionStackByLabel) ->+                                    let _ = "pushValue"+                                     in name+                                          ( let _ = "onReturn"+                                             in \farInp farExp v (!inp) ->+                                                  let _ = "lift2Value checkedHorizon=0"+                                                   in let _ = "pushValue"+                                                       in do+                                                            let dupv = \x -> x+                                                            reg <- GHC.STRef.newSTRef dupv+                                                            let _ = "iter"+                                                             in let onException loopInput =+                                                                      let _ = "onException"+                                                                       in \(!_exn) (!failInp) (!farInp) (!farExp) ->+                                                                            let _ = "comment: raiseAgainIfConsumed"+                                                                             in let _ = "saveInput checkedHorizon=0"+                                                                                 in let _ = "lift2Value checkedHorizon=0"+                                                                                     in if ( \( Data.Text.Internal.Text+                                                                                                  _+                                                                                                  i+                                                                                                  _+                                                                                                )+                                                                                              ( Data.Text.Internal.Text+                                                                                                  _+                                                                                                  j+                                                                                                  _+                                                                                                ) -> i GHC.Classes.== j+                                                                                           )+                                                                                          loopInput+                                                                                          failInp+                                                                                          then+                                                                                            let _ = "choicesBranch checkedHorizon=0"+                                                                                             in do+                                                                                                  sr <- GHC.STRef.readSTRef reg+                                                                                                  name+                                                                                                    ( let _ = "onReturn"+                                                                                                       in \farInp farExp v (!inp) ->+                                                                                                            let _ = "lift2Value checkedHorizon=0"+                                                                                                             in let _ = "lift2Value checkedHorizon=0"+                                                                                                                 in name+                                                                                                                      ( let _ = "onReturn"+                                                                                                                         in \farInp farExp v (!inp) ->+                                                                                                                              let _ = "lift2Value checkedHorizon=0"+                                                                                                                               in let _ = "resume"+                                                                                                                                   in callerOnReturn+                                                                                                                                        farInp+                                                                                                                                        farExp+                                                                                                                                        ( let _ = "resume.genCode"+                                                                                                                                           in v+                                                                                                                                        )+                                                                                                                                        inp+                                                                                                                      )+                                                                                                                      inp+                                                                                                                      Data.Map.Internal.Tip+                                                                                                    )+                                                                                                    failInp+                                                                                                    Data.Map.Internal.Tip+                                                                                          else+                                                                                            let _ = "choicesBranch.else"+                                                                                             in Data.Map.Strict.Internal.findWithDefault finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure callerOnExceptionStackByLabel Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp farInp farExp+                                                                    loop = \_callerOnReturn callerInput callerOnExceptionStackByLabel ->+                                                                      let _ = "pushValue"+                                                                       in let _ = "comment: satisfy ((GHC.Classes.==) '!')"+                                                                           in let inp = callerInput+                                                                               in let readFail = onException callerInput+                                                                                   in let _ = "checkHorizon.newCheck: checkedHorizon=0 minHoriz=4"+                                                                                       in if readMore (Symantic.Parser.Machine.Input.shiftRightText 3 inp)+                                                                                            then+                                                                                              let _ = "checkToken"+                                                                                               in let !(#+                                                                                                         c,+                                                                                                         cs+                                                                                                         #) = readNext inp+                                                                                                   in if (GHC.Classes.==) '!' c+                                                                                                        then+                                                                                                          let _ = "lift2Value checkedHorizon=4"+                                                                                                           in name+                                                                                                                ( let _ = "onReturn"+                                                                                                                   in \farInp farExp v (!inp) ->+                                                                                                                        let _ = "lift2Value checkedHorizon=0"+                                                                                                                         in name+                                                                                                                              ( let _ = "onReturn"+                                                                                                                                 in \farInp farExp v (!inp) ->+                                                                                                                                      let _ = "lift2Value checkedHorizon=0"+                                                                                                                                       in do+                                                                                                                                            sr <- GHC.STRef.readSTRef reg+                                                                                                                                            let _ = "lift2Value checkedHorizon=0"+                                                                                                                                             in do+                                                                                                                                                  let dupv = sr+                                                                                                                                                  GHC.STRef.writeSTRef reg dupv+                                                                                                                                                  let _ = "jump"+                                                                                                                                                   in loop (GHC.Err.error "invalid onReturn") inp (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure readFail Data.Map.Internal.Tip Data.Map.Internal.Tip)+                                                                                                                              )+                                                                                                                              inp+                                                                                                                              (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure readFail Data.Map.Internal.Tip Data.Map.Internal.Tip)+                                                                                                                )+                                                                                                                cs+                                                                                                                (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure readFail Data.Map.Internal.Tip Data.Map.Internal.Tip)+                                                                                                        else+                                                                                                          let _ = "checkToken.fail"+                                                                                                           in let failExp =+                                                                                                                    Data.Set.Internal.Bin+                                                                                                                      1+                                                                                                                      ( Symantic.Parser.Grammar.Combinators.SomeFailure+                                                                                                                          ( case inputToken of+                                                                                                                              (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken '!'+                                                                                                                          )+                                                                                                                      )+                                                                                                                      Data.Set.Internal.Tip+                                                                                                                      Data.Set.Internal.Tip+                                                                                                               in let (#+                                                                                                                        farInp,+                                                                                                                        farExp+                                                                                                                        #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp inp of+                                                                                                                          GHC.Types.LT ->+                                                                                                                            (#+                                                                                                                              inp,+                                                                                                                              failExp+                                                                                                                            #)+                                                                                                                          GHC.Types.EQ ->+                                                                                                                            (#+                                                                                                                              farInp,+                                                                                                                              failExp GHC.Base.<> farExp+                                                                                                                            #)+                                                                                                                          GHC.Types.GT ->+                                                                                                                            (#+                                                                                                                              farInp,+                                                                                                                              farExp+                                                                                                                            #)+                                                                                                                   in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp+                                                                                            else+                                                                                              let _ = "checkHorizon.newCheck.fail"+                                                                                               in let failExp =+                                                                                                        Data.Set.Internal.Bin+                                                                                                          1+                                                                                                          ( Symantic.Parser.Grammar.Combinators.SomeFailure+                                                                                                              ( case inputToken of+                                                                                                                  (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureHorizon @tok' 4+                                                                                                              )+                                                                                                          )+                                                                                                          Data.Set.Internal.Tip+                                                                                                          Data.Set.Internal.Tip+                                                                                                   in let (#+                                                                                                            farInp,+                                                                                                            farExp+                                                                                                            #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp inp of+                                                                                                              GHC.Types.LT ->+                                                                                                                (#+                                                                                                                  inp,+                                                                                                                  failExp+                                                                                                                #)+                                                                                                              GHC.Types.EQ ->+                                                                                                                (#+                                                                                                                  farInp,+                                                                                                                  failExp GHC.Base.<> farExp+                                                                                                                #)+                                                                                                              GHC.Types.GT ->+                                                                                                                (#+                                                                                                                  farInp,+                                                                                                                  farExp+                                                                                                                #)+                                                                                                       in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp+                                                                 in let _ = "jump"+                                                                     in loop callerOnReturn inp (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure (Data.Map.Strict.Internal.findWithDefault finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure callerOnExceptionStackByLabel) Data.Map.Internal.Tip Data.Map.Internal.Tip)+                                          )+                                          callerInput+                                          (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure (Data.Map.Strict.Internal.findWithDefault finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure callerOnExceptionStackByLabel) Data.Map.Internal.Tip Data.Map.Internal.Tip)+                                  name = \(!callerOnReturn) (!callerInput) (!callerOnExceptionStackByLabel) ->+                                    let _ = "pushValue"+                                     in name+                                          ( let _ = "onReturn"+                                             in \farInp farExp v (!inp) ->+                                                  let _ = "lift2Value checkedHorizon=0"+                                                   in let _ = "pushValue"+                                                       in do+                                                            let dupv = \x -> x+                                                            reg <- GHC.STRef.newSTRef dupv+                                                            let _ = "iter"+                                                             in let onException loopInput =+                                                                      let _ = "onException"+                                                                       in \(!_exn) (!failInp) (!farInp) (!farExp) ->+                                                                            let _ = "comment: raiseAgainIfConsumed"+                                                                             in let _ = "saveInput checkedHorizon=0"+                                                                                 in let _ = "lift2Value checkedHorizon=0"+                                                                                     in if ( \( Data.Text.Internal.Text+                                                                                                  _+                                                                                                  i+                                                                                                  _+                                                                                                )+                                                                                              ( Data.Text.Internal.Text+                                                                                                  _+                                                                                                  j+                                                                                                  _+                                                                                                ) -> i GHC.Classes.== j+                                                                                           )+                                                                                          loopInput+                                                                                          failInp+                                                                                          then+                                                                                            let _ = "choicesBranch checkedHorizon=0"+                                                                                             in do+                                                                                                  sr <- GHC.STRef.readSTRef reg+                                                                                                  let _ = "pushValue"+                                                                                                   in let _ = "lift2Value checkedHorizon=0"+                                                                                                       in let _ = "lift2Value checkedHorizon=0"+                                                                                                           in let _ = "resume"+                                                                                                               in callerOnReturn+                                                                                                                    farInp+                                                                                                                    farExp+                                                                                                                    ( let _ = "resume.genCode"+                                                                                                                       in GHC.Tuple . ()+                                                                                                                    )+                                                                                                                    failInp+                                                                                          else+                                                                                            let _ = "choicesBranch.else"+                                                                                             in Data.Map.Strict.Internal.findWithDefault finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure callerOnExceptionStackByLabel Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp farInp farExp+                                                                    loop = \_callerOnReturn callerInput callerOnExceptionStackByLabel ->+                                                                      let _ = "pushValue"+                                                                       in name+                                                                            ( let _ = "onReturn"+                                                                               in \farInp farExp v (!inp) ->+                                                                                    let _ = "lift2Value checkedHorizon=0"+                                                                                     in do+                                                                                          sr <- GHC.STRef.readSTRef reg+                                                                                          let _ = "lift2Value checkedHorizon=0"+                                                                                           in do+                                                                                                let dupv = sr+                                                                                                GHC.STRef.writeSTRef reg dupv+                                                                                                let _ = "jump"+                                                                                                 in loop (GHC.Err.error "invalid onReturn") inp (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure (onException callerInput) Data.Map.Internal.Tip Data.Map.Internal.Tip)+                                                                            )+                                                                            callerInput+                                                                            (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure (onException callerInput) Data.Map.Internal.Tip Data.Map.Internal.Tip)+                                                                 in let _ = "jump"+                                                                     in loop callerOnReturn inp (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure (Data.Map.Strict.Internal.findWithDefault finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure callerOnExceptionStackByLabel) Data.Map.Internal.Tip Data.Map.Internal.Tip)+                                          )+                                          callerInput+                                          (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure (Data.Map.Strict.Internal.findWithDefault finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure callerOnExceptionStackByLabel) Data.Map.Internal.Tip Data.Map.Internal.Tip)+                                  name = \(!callerOnReturn) (!callerInput) (!callerOnExceptionStackByLabel) ->+                                    let _ = "pushValue"+                                     in let _ = "catch ExceptionFailure checkedHorizon=0"+                                         in let onException =+                                                  let _ = "onException"+                                                   in \(!_exn) (!failInp) (!farInp) (!farExp) ->+                                                        let _ = "loadInput checkedHorizon=0"+                                                         in let _ = "checkHorizon.noCheck"+                                                             in Data.Map.Strict.Internal.findWithDefault finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure callerOnExceptionStackByLabel Symantic.Parser.Grammar.Combinators.ExceptionFailure callerInput farInp farExp+                                             in let _ = "pushValue"+                                                 in let _ = "comment: satisfy Parsers.Nandlang.nandIdentStart"+                                                     in let inp = callerInput+                                                         in let readFail = onException+                                                             in let _ = "checkHorizon.newCheck: checkedHorizon=0 minHoriz=2"+                                                                 in if readMore (Symantic.Parser.Machine.Input.shiftRightText 1 inp)+                                                                      then+                                                                        let _ = "checkToken"+                                                                         in let !(#+                                                                                   c,+                                                                                   cs+                                                                                   #) = readNext inp+                                                                             in if Parsers.Nandlang.nandIdentStart c+                                                                                  then+                                                                                    let _ = "lift2Value checkedHorizon=2"+                                                                                     in let _ = "pushValue"+                                                                                         in do+                                                                                              let dupv = \x -> x+                                                                                              reg <- GHC.STRef.newSTRef dupv+                                                                                              let _ = "iter"+                                                                                               in let onException loopInput =+                                                                                                        let _ = "onException"+                                                                                                         in \(!_exn) (!failInp) (!farInp) (!farExp) ->+                                                                                                              let _ = "comment: raiseAgainIfConsumed"+                                                                                                               in let _ = "saveInput checkedHorizon=0"+                                                                                                                   in let _ = "lift2Value checkedHorizon=0"+                                                                                                                       in if ( \( Data.Text.Internal.Text+                                                                                                                                    _+                                                                                                                                    i+                                                                                                                                    _+                                                                                                                                  )+                                                                                                                                ( Data.Text.Internal.Text+                                                                                                                                    _+                                                                                                                                    j+                                                                                                                                    _+                                                                                                                                  ) -> i GHC.Classes.== j+                                                                                                                             )+                                                                                                                            loopInput+                                                                                                                            failInp+                                                                                                                            then+                                                                                                                              let _ = "choicesBranch checkedHorizon=0"+                                                                                                                               in do+                                                                                                                                    sr <- GHC.STRef.readSTRef reg+                                                                                                                                    name+                                                                                                                                      ( let _ = "onReturn"+                                                                                                                                         in \farInp farExp v (!inp) ->+                                                                                                                                              let _ = "lift2Value checkedHorizon=0"+                                                                                                                                               in let _ = "lift2Value checkedHorizon=0"+                                                                                                                                                   in name+                                                                                                                                                        ( let _ = "onReturn"+                                                                                                                                                           in \farInp farExp v (!inp) ->+                                                                                                                                                                let _ = "lift2Value checkedHorizon=0"+                                                                                                                                                                 in let _ = "commit"+                                                                                                                                                                     in let _ = "lift2Value checkedHorizon=0"+                                                                                                                                                                         in name+                                                                                                                                                                              ( let _ = "onReturn"+                                                                                                                                                                                 in \farInp farExp v (!inp) ->+                                                                                                                                                                                      let _ = "lift2Value checkedHorizon=0"+                                                                                                                                                                                       in let _ = "resume"+                                                                                                                                                                                           in callerOnReturn+                                                                                                                                                                                                farInp+                                                                                                                                                                                                farExp+                                                                                                                                                                                                ( let _ = "resume.genCode"+                                                                                                                                                                                                   in v+                                                                                                                                                                                                )+                                                                                                                                                                                                inp+                                                                                                                                                                              )+                                                                                                                                                                              inp+                                                                                                                                                                              (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure (Data.Map.Strict.Internal.findWithDefault finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure callerOnExceptionStackByLabel) Data.Map.Internal.Tip Data.Map.Internal.Tip)+                                                                                                                                                        )+                                                                                                                                                        inp+                                                                                                                                                        Data.Map.Internal.Tip+                                                                                                                                      )+                                                                                                                                      failInp+                                                                                                                                      Data.Map.Internal.Tip+                                                                                                                            else+                                                                                                                              let _ = "choicesBranch.else"+                                                                                                                               in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp farInp farExp+                                                                                                      loop = \_callerOnReturn callerInput callerOnExceptionStackByLabel ->+                                                                                                        let _ = "pushValue"+                                                                                                         in let _ = "comment: satisfy Parsers.Nandlang.nandIdentLetter"+                                                                                                             in let inp = callerInput+                                                                                                                 in let readFail = onException callerInput+                                                                                                                     in let _ = "checkHorizon.newCheck: checkedHorizon=0 minHoriz=1"+                                                                                                                         in if readMore inp+                                                                                                                              then+                                                                                                                                let _ = "checkToken"+                                                                                                                                 in let !(#+                                                                                                                                           c,+                                                                                                                                           cs+                                                                                                                                           #) = readNext inp+                                                                                                                                     in if Parsers.Nandlang.nandIdentLetter c+                                                                                                                                          then+                                                                                                                                            let _ = "lift2Value checkedHorizon=1"+                                                                                                                                             in do+                                                                                                                                                  sr <- GHC.STRef.readSTRef reg+                                                                                                                                                  let _ = "lift2Value checkedHorizon=1"+                                                                                                                                                   in do+                                                                                                                                                        let dupv = sr+                                                                                                                                                        GHC.STRef.writeSTRef reg dupv+                                                                                                                                                        let _ = "jump"+                                                                                                                                                         in loop (GHC.Err.error "invalid onReturn") cs (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure readFail Data.Map.Internal.Tip Data.Map.Internal.Tip)+                                                                                                                                          else+                                                                                                                                            let _ = "checkToken.fail"+                                                                                                                                             in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure inp init Data.Set.Internal.empty+                                                                                                                              else+                                                                                                                                let _ = "checkHorizon.newCheck.fail"+                                                                                                                                 in let failExp =+                                                                                                                                          Data.Set.Internal.Bin+                                                                                                                                            1+                                                                                                                                            ( Symantic.Parser.Grammar.Combinators.SomeFailure+                                                                                                                                                ( case inputToken of+                                                                                                                                                    (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureHorizon @tok' 1+                                                                                                                                                )+                                                                                                                                            )+                                                                                                                                            Data.Set.Internal.Tip+                                                                                                                                            Data.Set.Internal.Tip+                                                                                                                                     in let (#+                                                                                                                                              farInp,+                                                                                                                                              farExp+                                                                                                                                              #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init inp of+                                                                                                                                                GHC.Types.LT ->+                                                                                                                                                  (#+                                                                                                                                                    inp,+                                                                                                                                                    failExp+                                                                                                                                                  #)+                                                                                                                                                GHC.Types.EQ ->+                                                                                                                                                  (#+                                                                                                                                                    init,+                                                                                                                                                    failExp GHC.Base.<> Data.Set.Internal.empty+                                                                                                                                                  #)+                                                                                                                                                GHC.Types.GT ->+                                                                                                                                                  (#+                                                                                                                                                    init,+                                                                                                                                                    Data.Set.Internal.empty+                                                                                                                                                  #)+                                                                                                                                         in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp+                                                                                                   in let _ = "jump"+                                                                                                       in loop callerOnReturn cs (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure readFail Data.Map.Internal.Tip Data.Map.Internal.Tip)+                                                                                  else+                                                                                    let _ = "checkToken.fail"+                                                                                     in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure inp init Data.Set.Internal.empty+                                                                      else+                                                                        let _ = "checkHorizon.newCheck.fail"+                                                                         in let failExp =+                                                                                  Data.Set.Internal.Bin+                                                                                    1+                                                                                    ( Symantic.Parser.Grammar.Combinators.SomeFailure+                                                                                        ( case inputToken of+                                                                                            (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureHorizon @tok' 2+                                                                                        )+                                                                                    )+                                                                                    Data.Set.Internal.Tip+                                                                                    Data.Set.Internal.Tip+                                                                             in let (#+                                                                                      farInp,+                                                                                      farExp+                                                                                      #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init inp of+                                                                                        GHC.Types.LT ->+                                                                                          (#+                                                                                            inp,+                                                                                            failExp+                                                                                          #)+                                                                                        GHC.Types.EQ ->+                                                                                          (#+                                                                                            init,+                                                                                            failExp GHC.Base.<> Data.Set.Internal.empty+                                                                                          #)+                                                                                        GHC.Types.GT ->+                                                                                          (#+                                                                                            init,+                                                                                            Data.Set.Internal.empty+                                                                                          #)+                                                                                 in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp+                                  name = \(!callerOnReturn) (!callerInput) (!callerOnExceptionStackByLabel) ->+                                    let _ = "pushValue"+                                     in let _ = "comment: satisfy ((GHC.Classes.==) '(')"+                                         in let inp = callerInput+                                             in let readFail = Data.Map.Strict.Internal.findWithDefault finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure callerOnExceptionStackByLabel+                                                 in let _ = "checkHorizon.newCheck: checkedHorizon=0 minHoriz=2"+                                                     in if readMore (Symantic.Parser.Machine.Input.shiftRightText 1 inp)+                                                          then+                                                            let _ = "checkToken"+                                                             in let !(#+                                                                       c,+                                                                       cs+                                                                       #) = readNext inp+                                                                 in if (GHC.Classes.==) '(' c+                                                                      then+                                                                        let _ = "lift2Value checkedHorizon=2"+                                                                         in name+                                                                              ( let _ = "onReturn"+                                                                                 in \farInp farExp v (!inp) ->+                                                                                      let _ = "lift2Value checkedHorizon=0"+                                                                                       in let _ = "resume"+                                                                                           in callerOnReturn+                                                                                                farInp+                                                                                                farExp+                                                                                                ( let _ = "resume.genCode"+                                                                                                   in '('+                                                                                                )+                                                                                                inp+                                                                              )+                                                                              cs+                                                                              (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure readFail Data.Map.Internal.Tip Data.Map.Internal.Tip)+                                                                      else+                                                                        let _ = "checkToken.fail"+                                                                         in let failExp =+                                                                                  Data.Set.Internal.Bin+                                                                                    1+                                                                                    ( Symantic.Parser.Grammar.Combinators.SomeFailure+                                                                                        ( case inputToken of+                                                                                            (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken '('+                                                                                        )+                                                                                    )+                                                                                    Data.Set.Internal.Tip+                                                                                    Data.Set.Internal.Tip+                                                                             in let (#+                                                                                      farInp,+                                                                                      farExp+                                                                                      #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init inp of+                                                                                        GHC.Types.LT ->+                                                                                          (#+                                                                                            inp,+                                                                                            failExp+                                                                                          #)+                                                                                        GHC.Types.EQ ->+                                                                                          (#+                                                                                            init,+                                                                                            failExp GHC.Base.<> Data.Set.Internal.empty+                                                                                          #)+                                                                                        GHC.Types.GT ->+                                                                                          (#+                                                                                            init,+                                                                                            Data.Set.Internal.empty+                                                                                          #)+                                                                                 in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp+                                                          else+                                                            let _ = "checkHorizon.newCheck.fail"+                                                             in let failExp =+                                                                      Data.Set.Internal.Bin+                                                                        1+                                                                        ( Symantic.Parser.Grammar.Combinators.SomeFailure+                                                                            ( case inputToken of+                                                                                (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureHorizon @tok' 2+                                                                            )+                                                                        )+                                                                        Data.Set.Internal.Tip+                                                                        Data.Set.Internal.Tip+                                                                 in let (#+                                                                          farInp,+                                                                          farExp+                                                                          #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init inp of+                                                                            GHC.Types.LT ->+                                                                              (#+                                                                                inp,+                                                                                failExp+                                                                              #)+                                                                            GHC.Types.EQ ->+                                                                              (#+                                                                                init,+                                                                                failExp GHC.Base.<> Data.Set.Internal.empty+                                                                              #)+                                                                            GHC.Types.GT ->+                                                                              (#+                                                                                init,+                                                                                Data.Set.Internal.empty+                                                                              #)+                                                                     in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp+                                  name = \(!callerOnReturn) (!callerInput) (!callerOnExceptionStackByLabel) ->+                                    let _ = "pushValue"+                                     in let _ = "comment: satisfy ((GHC.Classes.==) ')')"+                                         in let inp = callerInput+                                             in let readFail = Data.Map.Strict.Internal.findWithDefault finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure callerOnExceptionStackByLabel+                                                 in let _ = "checkHorizon.newCheck: checkedHorizon=0 minHoriz=2"+                                                     in if readMore (Symantic.Parser.Machine.Input.shiftRightText 1 inp)+                                                          then+                                                            let _ = "checkToken"+                                                             in let !(#+                                                                       c,+                                                                       cs+                                                                       #) = readNext inp+                                                                 in if (GHC.Classes.==) ')' c+                                                                      then+                                                                        let _ = "lift2Value checkedHorizon=2"+                                                                         in name+                                                                              ( let _ = "onReturn"+                                                                                 in \farInp farExp v (!inp) ->+                                                                                      let _ = "lift2Value checkedHorizon=0"+                                                                                       in let _ = "resume"+                                                                                           in callerOnReturn+                                                                                                farInp+                                                                                                farExp+                                                                                                ( let _ = "resume.genCode"+                                                                                                   in ')'+                                                                                                )+                                                                                                inp+                                                                              )+                                                                              cs+                                                                              (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure readFail Data.Map.Internal.Tip Data.Map.Internal.Tip)+                                                                      else+                                                                        let _ = "checkToken.fail"+                                                                         in let failExp =+                                                                                  Data.Set.Internal.Bin+                                                                                    1+                                                                                    ( Symantic.Parser.Grammar.Combinators.SomeFailure+                                                                                        ( case inputToken of+                                                                                            (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken ')'+                                                                                        )+                                                                                    )+                                                                                    Data.Set.Internal.Tip+                                                                                    Data.Set.Internal.Tip+                                                                             in let (#+                                                                                      farInp,+                                                                                      farExp+                                                                                      #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init inp of+                                                                                        GHC.Types.LT ->+                                                                                          (#+                                                                                            inp,+                                                                                            failExp+                                                                                          #)+                                                                                        GHC.Types.EQ ->+                                                                                          (#+                                                                                            init,+                                                                                            failExp GHC.Base.<> Data.Set.Internal.empty+                                                                                          #)+                                                                                        GHC.Types.GT ->+                                                                                          (#+                                                                                            init,+                                                                                            Data.Set.Internal.empty+                                                                                          #)+                                                                                 in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp+                                                          else+                                                            let _ = "checkHorizon.newCheck.fail"+                                                             in let failExp =+                                                                      Data.Set.Internal.Bin+                                                                        1+                                                                        ( Symantic.Parser.Grammar.Combinators.SomeFailure+                                                                            ( case inputToken of+                                                                                (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureHorizon @tok' 2+                                                                            )+                                                                        )+                                                                        Data.Set.Internal.Tip+                                                                        Data.Set.Internal.Tip+                                                                 in let (#+                                                                          farInp,+                                                                          farExp+                                                                          #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init inp of+                                                                            GHC.Types.LT ->+                                                                              (#+                                                                                inp,+                                                                                failExp+                                                                              #)+                                                                            GHC.Types.EQ ->+                                                                              (#+                                                                                init,+                                                                                failExp GHC.Base.<> Data.Set.Internal.empty+                                                                              #)+                                                                            GHC.Types.GT ->+                                                                              (#+                                                                                init,+                                                                                Data.Set.Internal.empty+                                                                              #)+                                                                     in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp+                                  name = \(!callerOnReturn) (!callerInput) (!callerOnExceptionStackByLabel) ->+                                    let _ = "pushValue"+                                     in let _ = "comment: satisfy ((GHC.Classes.==) ',')"+                                         in let inp = callerInput+                                             in let readFail = Data.Map.Strict.Internal.findWithDefault finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure callerOnExceptionStackByLabel+                                                 in let _ = "checkHorizon.newCheck: checkedHorizon=0 minHoriz=2"+                                                     in if readMore (Symantic.Parser.Machine.Input.shiftRightText 1 inp)+                                                          then+                                                            let _ = "checkToken"+                                                             in let !(#+                                                                       c,+                                                                       cs+                                                                       #) = readNext inp+                                                                 in if (GHC.Classes.==) ',' c+                                                                      then+                                                                        let _ = "lift2Value checkedHorizon=2"+                                                                         in name+                                                                              ( let _ = "onReturn"+                                                                                 in \farInp farExp v (!inp) ->+                                                                                      let _ = "lift2Value checkedHorizon=0"+                                                                                       in let _ = "resume"+                                                                                           in callerOnReturn+                                                                                                farInp+                                                                                                farExp+                                                                                                ( let _ = "resume.genCode"+                                                                                                   in ','+                                                                                                )+                                                                                                inp+                                                                              )+                                                                              cs+                                                                              (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure readFail Data.Map.Internal.Tip Data.Map.Internal.Tip)+                                                                      else+                                                                        let _ = "checkToken.fail"+                                                                         in let failExp =+                                                                                  Data.Set.Internal.Bin+                                                                                    1+                                                                                    ( Symantic.Parser.Grammar.Combinators.SomeFailure+                                                                                        ( case inputToken of+                                                                                            (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken ','+                                                                                        )+                                                                                    )+                                                                                    Data.Set.Internal.Tip+                                                                                    Data.Set.Internal.Tip+                                                                             in let (#+                                                                                      farInp,+                                                                                      farExp+                                                                                      #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init inp of+                                                                                        GHC.Types.LT ->+                                                                                          (#+                                                                                            inp,+                                                                                            failExp+                                                                                          #)+                                                                                        GHC.Types.EQ ->+                                                                                          (#+                                                                                            init,+                                                                                            failExp GHC.Base.<> Data.Set.Internal.empty+                                                                                          #)+                                                                                        GHC.Types.GT ->+                                                                                          (#+                                                                                            init,+                                                                                            Data.Set.Internal.empty+                                                                                          #)+                                                                                 in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp+                                                          else+                                                            let _ = "checkHorizon.newCheck.fail"+                                                             in let failExp =+                                                                      Data.Set.Internal.Bin+                                                                        1+                                                                        ( Symantic.Parser.Grammar.Combinators.SomeFailure+                                                                            ( case inputToken of+                                                                                (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureHorizon @tok' 2+                                                                            )+                                                                        )+                                                                        Data.Set.Internal.Tip+                                                                        Data.Set.Internal.Tip+                                                                 in let (#+                                                                          farInp,+                                                                          farExp+                                                                          #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init inp of+                                                                            GHC.Types.LT ->+                                                                              (#+                                                                                inp,+                                                                                failExp+                                                                              #)+                                                                            GHC.Types.EQ ->+                                                                              (#+                                                                                init,+                                                                                failExp GHC.Base.<> Data.Set.Internal.empty+                                                                              #)+                                                                            GHC.Types.GT ->+                                                                              (#+                                                                                init,+                                                                                Data.Set.Internal.empty+                                                                              #)+                                                                     in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp+                                  name = \(!callerOnReturn) (!callerInput) (!callerOnExceptionStackByLabel) ->+                                    let _ = "pushValue"+                                     in let _ = "comment: satisfy ((GHC.Classes.==) ';')"+                                         in let inp = callerInput+                                             in let readFail = Data.Map.Strict.Internal.findWithDefault finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure callerOnExceptionStackByLabel+                                                 in let _ = "checkHorizon.newCheck: checkedHorizon=0 minHoriz=2"+                                                     in if readMore (Symantic.Parser.Machine.Input.shiftRightText 1 inp)+                                                          then+                                                            let _ = "checkToken"+                                                             in let !(#+                                                                       c,+                                                                       cs+                                                                       #) = readNext inp+                                                                 in if (GHC.Classes.==) ';' c+                                                                      then+                                                                        let _ = "lift2Value checkedHorizon=2"+                                                                         in name+                                                                              ( let _ = "onReturn"+                                                                                 in \farInp farExp v (!inp) ->+                                                                                      let _ = "lift2Value checkedHorizon=0"+                                                                                       in let _ = "resume"+                                                                                           in callerOnReturn+                                                                                                farInp+                                                                                                farExp+                                                                                                ( let _ = "resume.genCode"+                                                                                                   in ';'+                                                                                                )+                                                                                                inp+                                                                              )+                                                                              cs+                                                                              (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure readFail Data.Map.Internal.Tip Data.Map.Internal.Tip)+                                                                      else+                                                                        let _ = "checkToken.fail"+                                                                         in let failExp =+                                                                                  Data.Set.Internal.Bin+                                                                                    1+                                                                                    ( Symantic.Parser.Grammar.Combinators.SomeFailure+                                                                                        ( case inputToken of+                                                                                            (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken ';'+                                                                                        )+                                                                                    )+                                                                                    Data.Set.Internal.Tip+                                                                                    Data.Set.Internal.Tip+                                                                             in let (#+                                                                                      farInp,+                                                                                      farExp+                                                                                      #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init inp of+                                                                                        GHC.Types.LT ->+                                                                                          (#+                                                                                            inp,+                                                                                            failExp+                                                                                          #)+                                                                                        GHC.Types.EQ ->+                                                                                          (#+                                                                                            init,+                                                                                            failExp GHC.Base.<> Data.Set.Internal.empty+                                                                                          #)+                                                                                        GHC.Types.GT ->+                                                                                          (#+                                                                                            init,+                                                                                            Data.Set.Internal.empty+                                                                                          #)+                                                                                 in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp+                                                          else+                                                            let _ = "checkHorizon.newCheck.fail"+                                                             in let failExp =+                                                                      Data.Set.Internal.Bin+                                                                        1+                                                                        ( Symantic.Parser.Grammar.Combinators.SomeFailure+                                                                            ( case inputToken of+                                                                                (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureHorizon @tok' 2+                                                                            )+                                                                        )+                                                                        Data.Set.Internal.Tip+                                                                        Data.Set.Internal.Tip+                                                                 in let (#+                                                                          farInp,+                                                                          farExp+                                                                          #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init inp of+                                                                            GHC.Types.LT ->+                                                                              (#+                                                                                inp,+                                                                                failExp+                                                                              #)+                                                                            GHC.Types.EQ ->+                                                                              (#+                                                                                init,+                                                                                failExp GHC.Base.<> Data.Set.Internal.empty+                                                                              #)+                                                                            GHC.Types.GT ->+                                                                              (#+                                                                                init,+                                                                                Data.Set.Internal.empty+                                                                              #)+                                                                     in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp+                                  name = \(!callerOnReturn) (!callerInput) (!callerOnExceptionStackByLabel) ->+                                    let _ = "pushValue"+                                     in let _ = "comment: satisfy ((GHC.Classes.==) '[')"+                                         in let inp = callerInput+                                             in let readFail = Data.Map.Strict.Internal.findWithDefault finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure callerOnExceptionStackByLabel+                                                 in let _ = "checkHorizon.newCheck: checkedHorizon=0 minHoriz=5"+                                                     in if readMore (Symantic.Parser.Machine.Input.shiftRightText 4 inp)+                                                          then+                                                            let _ = "checkToken"+                                                             in let !(#+                                                                       c,+                                                                       cs+                                                                       #) = readNext inp+                                                                 in if (GHC.Classes.==) '[' c+                                                                      then+                                                                        let _ = "lift2Value checkedHorizon=5"+                                                                         in name+                                                                              ( let _ = "onReturn"+                                                                                 in \farInp farExp v (!inp) ->+                                                                                      let _ = "lift2Value checkedHorizon=0"+                                                                                       in name+                                                                                            ( let _ = "onReturn"+                                                                                               in \farInp farExp v (!inp) ->+                                                                                                    let _ = "lift2Value checkedHorizon=0"+                                                                                                     in let _ = "pushValue"+                                                                                                         in do+                                                                                                              let dupv = \x -> x+                                                                                                              reg <- GHC.STRef.newSTRef dupv+                                                                                                              let _ = "iter"+                                                                                                               in let onException loopInput =+                                                                                                                        let _ = "onException"+                                                                                                                         in \(!_exn) (!failInp) (!farInp) (!farExp) ->+                                                                                                                              let _ = "comment: raiseAgainIfConsumed"+                                                                                                                               in let _ = "saveInput checkedHorizon=0"+                                                                                                                                   in let _ = "lift2Value checkedHorizon=0"+                                                                                                                                       in if ( \( Data.Text.Internal.Text+                                                                                                                                                    _+                                                                                                                                                    i+                                                                                                                                                    _+                                                                                                                                                  )+                                                                                                                                                ( Data.Text.Internal.Text+                                                                                                                                                    _+                                                                                                                                                    j+                                                                                                                                                    _+                                                                                                                                                  ) -> i GHC.Classes.== j+                                                                                                                                             )+                                                                                                                                            loopInput+                                                                                                                                            failInp+                                                                                                                                            then+                                                                                                                                              let _ = "choicesBranch checkedHorizon=0"+                                                                                                                                               in do+                                                                                                                                                    sr <- GHC.STRef.readSTRef reg+                                                                                                                                                    let _ = "pushValue"+                                                                                                                                                     in let _ = "lift2Value checkedHorizon=0"+                                                                                                                                                         in let _ = "lift2Value checkedHorizon=0"+                                                                                                                                                             in let _ = "comment: satisfy ((GHC.Classes.==) ']')"+                                                                                                                                                                 in let inp = failInp+                                                                                                                                                                     in let readFail = readFail+                                                                                                                                                                         in let _ = "checkHorizon.newCheck: checkedHorizon=0 minHoriz=2"+                                                                                                                                                                             in if readMore (Symantic.Parser.Machine.Input.shiftRightText 1 inp)+                                                                                                                                                                                  then+                                                                                                                                                                                    let _ = "checkToken"+                                                                                                                                                                                     in let !(#+                                                                                                                                                                                               c,+                                                                                                                                                                                               cs+                                                                                                                                                                                               #) = readNext inp+                                                                                                                                                                                         in if (GHC.Classes.==) ']' c+                                                                                                                                                                                              then+                                                                                                                                                                                                let _ = "lift2Value checkedHorizon=2"+                                                                                                                                                                                                 in name+                                                                                                                                                                                                      ( let _ = "onReturn"+                                                                                                                                                                                                         in \farInp farExp v (!inp) ->+                                                                                                                                                                                                              let _ = "lift2Value checkedHorizon=0"+                                                                                                                                                                                                               in let _ = "resume"+                                                                                                                                                                                                                   in callerOnReturn+                                                                                                                                                                                                                        farInp+                                                                                                                                                                                                                        farExp+                                                                                                                                                                                                                        ( let _ = "resume.genCode"+                                                                                                                                                                                                                           in GHC.Tuple . ()+                                                                                                                                                                                                                        )+                                                                                                                                                                                                                        inp+                                                                                                                                                                                                      )+                                                                                                                                                                                                      cs+                                                                                                                                                                                                      (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure readFail Data.Map.Internal.Tip Data.Map.Internal.Tip)+                                                                                                                                                                                              else+                                                                                                                                                                                                let _ = "checkToken.fail"+                                                                                                                                                                                                 in let failExp =+                                                                                                                                                                                                          Data.Set.Internal.Bin+                                                                                                                                                                                                            1+                                                                                                                                                                                                            ( Symantic.Parser.Grammar.Combinators.SomeFailure+                                                                                                                                                                                                                ( case inputToken of+                                                                                                                                                                                                                    (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken ']'+                                                                                                                                                                                                                )+                                                                                                                                                                                                            )+                                                                                                                                                                                                            Data.Set.Internal.Tip+                                                                                                                                                                                                            Data.Set.Internal.Tip+                                                                                                                                                                                                     in let (#+                                                                                                                                                                                                              farInp,+                                                                                                                                                                                                              farExp+                                                                                                                                                                                                              #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp inp of+                                                                                                                                                                                                                GHC.Types.LT ->+                                                                                                                                                                                                                  (#+                                                                                                                                                                                                                    inp,+                                                                                                                                                                                                                    failExp+                                                                                                                                                                                                                  #)+                                                                                                                                                                                                                GHC.Types.EQ ->+                                                                                                                                                                                                                  (#+                                                                                                                                                                                                                    farInp,+                                                                                                                                                                                                                    failExp GHC.Base.<> farExp+                                                                                                                                                                                                                  #)+                                                                                                                                                                                                                GHC.Types.GT ->+                                                                                                                                                                                                                  (#+                                                                                                                                                                                                                    farInp,+                                                                                                                                                                                                                    farExp+                                                                                                                                                                                                                  #)+                                                                                                                                                                                                         in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp+                                                                                                                                                                                  else+                                                                                                                                                                                    let _ = "checkHorizon.newCheck.fail"+                                                                                                                                                                                     in let failExp =+                                                                                                                                                                                              Data.Set.Internal.Bin+                                                                                                                                                                                                1+                                                                                                                                                                                                ( Symantic.Parser.Grammar.Combinators.SomeFailure+                                                                                                                                                                                                    ( case inputToken of+                                                                                                                                                                                                        (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureHorizon @tok' 2+                                                                                                                                                                                                    )+                                                                                                                                                                                                )+                                                                                                                                                                                                Data.Set.Internal.Tip+                                                                                                                                                                                                Data.Set.Internal.Tip+                                                                                                                                                                                         in let (#+                                                                                                                                                                                                  farInp,+                                                                                                                                                                                                  farExp+                                                                                                                                                                                                  #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp inp of+                                                                                                                                                                                                    GHC.Types.LT ->+                                                                                                                                                                                                      (#+                                                                                                                                                                                                        inp,+                                                                                                                                                                                                        failExp+                                                                                                                                                                                                      #)+                                                                                                                                                                                                    GHC.Types.EQ ->+                                                                                                                                                                                                      (#+                                                                                                                                                                                                        farInp,+                                                                                                                                                                                                        failExp GHC.Base.<> farExp+                                                                                                                                                                                                      #)+                                                                                                                                                                                                    GHC.Types.GT ->+                                                                                                                                                                                                      (#+                                                                                                                                                                                                        farInp,+                                                                                                                                                                                                        farExp+                                                                                                                                                                                                      #)+                                                                                                                                                                                             in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp+                                                                                                                                            else+                                                                                                                                              let _ = "choicesBranch.else"+                                                                                                                                               in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp farInp farExp+                                                                                                                      loop = \_callerOnReturn callerInput callerOnExceptionStackByLabel ->+                                                                                                                        let _ = "pushValue"+                                                                                                                         in name+                                                                                                                              ( let _ = "onReturn"+                                                                                                                                 in \farInp farExp v (!inp) ->+                                                                                                                                      let _ = "lift2Value checkedHorizon=0"+                                                                                                                                       in do+                                                                                                                                            sr <- GHC.STRef.readSTRef reg+                                                                                                                                            let _ = "lift2Value checkedHorizon=0"+                                                                                                                                             in do+                                                                                                                                                  let dupv = sr+                                                                                                                                                  GHC.STRef.writeSTRef reg dupv+                                                                                                                                                  let _ = "jump"+                                                                                                                                                   in loop (GHC.Err.error "invalid onReturn") inp (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure (onException callerInput) Data.Map.Internal.Tip Data.Map.Internal.Tip)+                                                                                                                              )+                                                                                                                              callerInput+                                                                                                                              (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure (onException callerInput) Data.Map.Internal.Tip Data.Map.Internal.Tip)+                                                                                                                   in let _ = "jump"+                                                                                                                       in loop callerOnReturn inp (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure readFail Data.Map.Internal.Tip Data.Map.Internal.Tip)+                                                                                            )+                                                                                            inp+                                                                                            (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure readFail Data.Map.Internal.Tip Data.Map.Internal.Tip)+                                                                              )+                                                                              cs+                                                                              (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure readFail Data.Map.Internal.Tip Data.Map.Internal.Tip)+                                                                      else+                                                                        let _ = "checkToken.fail"+                                                                         in let failExp =+                                                                                  Data.Set.Internal.Bin+                                                                                    1+                                                                                    ( Symantic.Parser.Grammar.Combinators.SomeFailure+                                                                                        ( case inputToken of+                                                                                            (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken '['+                                                                                        )+                                                                                    )+                                                                                    Data.Set.Internal.Tip+                                                                                    Data.Set.Internal.Tip+                                                                             in let (#+                                                                                      farInp,+                                                                                      farExp+                                                                                      #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init inp of+                                                                                        GHC.Types.LT ->+                                                                                          (#+                                                                                            inp,+                                                                                            failExp+                                                                                          #)+                                                                                        GHC.Types.EQ ->+                                                                                          (#+                                                                                            init,+                                                                                            failExp GHC.Base.<> Data.Set.Internal.empty+                                                                                          #)+                                                                                        GHC.Types.GT ->+                                                                                          (#+                                                                                            init,+                                                                                            Data.Set.Internal.empty+                                                                                          #)+                                                                                 in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp+                                                          else+                                                            let _ = "checkHorizon.newCheck.fail"+                                                             in let failExp =+                                                                      Data.Set.Internal.Bin+                                                                        1+                                                                        ( Symantic.Parser.Grammar.Combinators.SomeFailure+                                                                            ( case inputToken of+                                                                                (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureHorizon @tok' 5+                                                                            )+                                                                        )+                                                                        Data.Set.Internal.Tip+                                                                        Data.Set.Internal.Tip+                                                                 in let (#+                                                                          farInp,+                                                                          farExp+                                                                          #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init inp of+                                                                            GHC.Types.LT ->+                                                                              (#+                                                                                inp,+                                                                                failExp+                                                                              #)+                                                                            GHC.Types.EQ ->+                                                                              (#+                                                                                init,+                                                                                failExp GHC.Base.<> Data.Set.Internal.empty+                                                                              #)+                                                                            GHC.Types.GT ->+                                                                              (#+                                                                                init,+                                                                                Data.Set.Internal.empty+                                                                              #)+                                                                     in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp+                                  name = \(!callerOnReturn) (!callerInput) (!callerOnExceptionStackByLabel) ->+                                    let _ = "pushValue"+                                     in let _ = "comment: satisfy ((GHC.Classes.==) '{')"+                                         in let inp = callerInput+                                             in let readFail = Data.Map.Strict.Internal.findWithDefault finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure callerOnExceptionStackByLabel+                                                 in let _ = "checkHorizon.newCheck: checkedHorizon=0 minHoriz=4"+                                                     in if readMore (Symantic.Parser.Machine.Input.shiftRightText 3 inp)+                                                          then+                                                            let _ = "checkToken"+                                                             in let !(#+                                                                       c,+                                                                       cs+                                                                       #) = readNext inp+                                                                 in if (GHC.Classes.==) '{' c+                                                                      then+                                                                        let _ = "lift2Value checkedHorizon=4"+                                                                         in name+                                                                              ( let _ = "onReturn"+                                                                                 in \farInp farExp v (!inp) ->+                                                                                      let _ = "lift2Value checkedHorizon=0"+                                                                                       in let _ = "pushValue"+                                                                                           in do+                                                                                                let dupv = \x -> x+                                                                                                reg <- GHC.STRef.newSTRef dupv+                                                                                                let _ = "iter"+                                                                                                 in let onException loopInput =+                                                                                                          let _ = "onException"+                                                                                                           in \(!_exn) (!failInp) (!farInp) (!farExp) ->+                                                                                                                let _ = "comment: raiseAgainIfConsumed"+                                                                                                                 in let _ = "saveInput checkedHorizon=0"+                                                                                                                     in let _ = "lift2Value checkedHorizon=0"+                                                                                                                         in if ( \( Data.Text.Internal.Text+                                                                                                                                      _+                                                                                                                                      i+                                                                                                                                      _+                                                                                                                                    )+                                                                                                                                  ( Data.Text.Internal.Text+                                                                                                                                      _+                                                                                                                                      j+                                                                                                                                      _+                                                                                                                                    ) -> i GHC.Classes.== j+                                                                                                                               )+                                                                                                                              loopInput+                                                                                                                              failInp+                                                                                                                              then+                                                                                                                                let _ = "choicesBranch checkedHorizon=0"+                                                                                                                                 in do+                                                                                                                                      sr <- GHC.STRef.readSTRef reg+                                                                                                                                      name+                                                                                                                                        ( let _ = "onReturn"+                                                                                                                                           in \farInp farExp v (!inp) ->+                                                                                                                                                let _ = "lift2Value checkedHorizon=0"+                                                                                                                                                 in let _ = "lift2Value checkedHorizon=0"+                                                                                                                                                     in name+                                                                                                                                                          ( let _ = "onReturn"+                                                                                                                                                             in \farInp farExp v (!inp) ->+                                                                                                                                                                  let _ = "lift2Value checkedHorizon=0"+                                                                                                                                                                   in let _ = "comment: satisfy ((GHC.Classes.==) '}')"+                                                                                                                                                                       in let inp = inp+                                                                                                                                                                           in let readFail = readFail+                                                                                                                                                                               in let _ = "checkHorizon.newCheck: checkedHorizon=0 minHoriz=2"+                                                                                                                                                                                   in if readMore (Symantic.Parser.Machine.Input.shiftRightText 1 inp)+                                                                                                                                                                                        then+                                                                                                                                                                                          let _ = "checkToken"+                                                                                                                                                                                           in let !(#+                                                                                                                                                                                                     c,+                                                                                                                                                                                                     cs+                                                                                                                                                                                                     #) = readNext inp+                                                                                                                                                                                               in if (GHC.Classes.==) '}' c+                                                                                                                                                                                                    then+                                                                                                                                                                                                      let _ = "lift2Value checkedHorizon=2"+                                                                                                                                                                                                       in name+                                                                                                                                                                                                            ( let _ = "onReturn"+                                                                                                                                                                                                               in \farInp farExp v (!inp) ->+                                                                                                                                                                                                                    let _ = "lift2Value checkedHorizon=0"+                                                                                                                                                                                                                     in let _ = "resume"+                                                                                                                                                                                                                         in callerOnReturn+                                                                                                                                                                                                                              farInp+                                                                                                                                                                                                                              farExp+                                                                                                                                                                                                                              ( let _ = "resume.genCode"+                                                                                                                                                                                                                                 in v+                                                                                                                                                                                                                              )+                                                                                                                                                                                                                              inp+                                                                                                                                                                                                            )+                                                                                                                                                                                                            cs+                                                                                                                                                                                                            (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure readFail Data.Map.Internal.Tip Data.Map.Internal.Tip)+                                                                                                                                                                                                    else+                                                                                                                                                                                                      let _ = "checkToken.fail"+                                                                                                                                                                                                       in let failExp =+                                                                                                                                                                                                                Data.Set.Internal.Bin+                                                                                                                                                                                                                  1+                                                                                                                                                                                                                  ( Symantic.Parser.Grammar.Combinators.SomeFailure+                                                                                                                                                                                                                      ( case inputToken of+                                                                                                                                                                                                                          (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken '}'+                                                                                                                                                                                                                      )+                                                                                                                                                                                                                  )+                                                                                                                                                                                                                  Data.Set.Internal.Tip+                                                                                                                                                                                                                  Data.Set.Internal.Tip+                                                                                                                                                                                                           in let (#+                                                                                                                                                                                                                    farInp,+                                                                                                                                                                                                                    farExp+                                                                                                                                                                                                                    #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp inp of+                                                                                                                                                                                                                      GHC.Types.LT ->+                                                                                                                                                                                                                        (#+                                                                                                                                                                                                                          inp,+                                                                                                                                                                                                                          failExp+                                                                                                                                                                                                                        #)+                                                                                                                                                                                                                      GHC.Types.EQ ->+                                                                                                                                                                                                                        (#+                                                                                                                                                                                                                          farInp,+                                                                                                                                                                                                                          failExp GHC.Base.<> farExp+                                                                                                                                                                                                                        #)+                                                                                                                                                                                                                      GHC.Types.GT ->+                                                                                                                                                                                                                        (#+                                                                                                                                                                                                                          farInp,+                                                                                                                                                                                                                          farExp+                                                                                                                                                                                                                        #)+                                                                                                                                                                                                               in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp+                                                                                                                                                                                        else+                                                                                                                                                                                          let _ = "checkHorizon.newCheck.fail"+                                                                                                                                                                                           in let failExp =+                                                                                                                                                                                                    Data.Set.Internal.Bin+                                                                                                                                                                                                      1+                                                                                                                                                                                                      ( Symantic.Parser.Grammar.Combinators.SomeFailure+                                                                                                                                                                                                          ( case inputToken of+                                                                                                                                                                                                              (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureHorizon @tok' 2+                                                                                                                                                                                                          )+                                                                                                                                                                                                      )+                                                                                                                                                                                                      Data.Set.Internal.Tip+                                                                                                                                                                                                      Data.Set.Internal.Tip+                                                                                                                                                                                               in let (#+                                                                                                                                                                                                        farInp,+                                                                                                                                                                                                        farExp+                                                                                                                                                                                                        #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp inp of+                                                                                                                                                                                                          GHC.Types.LT ->+                                                                                                                                                                                                            (#+                                                                                                                                                                                                              inp,+                                                                                                                                                                                                              failExp+                                                                                                                                                                                                            #)+                                                                                                                                                                                                          GHC.Types.EQ ->+                                                                                                                                                                                                            (#+                                                                                                                                                                                                              farInp,+                                                                                                                                                                                                              failExp GHC.Base.<> farExp+                                                                                                                                                                                                            #)+                                                                                                                                                                                                          GHC.Types.GT ->+                                                                                                                                                                                                            (#+                                                                                                                                                                                                              farInp,+                                                                                                                                                                                                              farExp+                                                                                                                                                                                                            #)+                                                                                                                                                                                                   in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp+                                                                                                                                                          )+                                                                                                                                                          inp+                                                                                                                                                          Data.Map.Internal.Tip+                                                                                                                                        )+                                                                                                                                        failInp+                                                                                                                                        Data.Map.Internal.Tip+                                                                                                                              else+                                                                                                                                let _ = "choicesBranch.else"+                                                                                                                                 in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp farInp farExp+                                                                                                        loop = \_callerOnReturn callerInput callerOnExceptionStackByLabel ->+                                                                                                          let _ = "pushValue"+                                                                                                           in let join = \farInp farExp v (!inp) ->+                                                                                                                    let _ = "lift2Value checkedHorizon=0"+                                                                                                                     in do+                                                                                                                          sr <- GHC.STRef.readSTRef reg+                                                                                                                          let _ = "lift2Value checkedHorizon=0"+                                                                                                                           in do+                                                                                                                                let dupv = sr+                                                                                                                                GHC.STRef.writeSTRef reg dupv+                                                                                                                                let _ = "jump"+                                                                                                                                 in loop (GHC.Err.error "invalid onReturn") inp (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure (onException callerInput) Data.Map.Internal.Tip Data.Map.Internal.Tip)+                                                                                                               in let _ = "catch ExceptionFailure checkedHorizon=0"+                                                                                                                   in let onException =+                                                                                                                            let _ = "onException"+                                                                                                                             in \(!_exn) (!failInp) (!farInp) (!farExp) ->+                                                                                                                                  let _ = "comment: raiseAgainIfConsumed"+                                                                                                                                   in let _ = "saveInput checkedHorizon=0"+                                                                                                                                       in let _ = "lift2Value checkedHorizon=0"+                                                                                                                                           in if ( \( Data.Text.Internal.Text+                                                                                                                                                        _+                                                                                                                                                        i+                                                                                                                                                        _+                                                                                                                                                      )+                                                                                                                                                    ( Data.Text.Internal.Text+                                                                                                                                                        _+                                                                                                                                                        j+                                                                                                                                                        _+                                                                                                                                                      ) -> i GHC.Classes.== j+                                                                                                                                                 )+                                                                                                                                                callerInput+                                                                                                                                                failInp+                                                                                                                                                then+                                                                                                                                                  let _ = "choicesBranch checkedHorizon=0"+                                                                                                                                                   in let _ = "catch ExceptionFailure checkedHorizon=0"+                                                                                                                                                       in let onException =+                                                                                                                                                                let _ = "onException"+                                                                                                                                                                 in \(!_exn) (!failInp) (!farInp) (!farExp) ->+                                                                                                                                                                      let _ = "comment: raiseAgainIfConsumed"+                                                                                                                                                                       in let _ = "saveInput checkedHorizon=0"+                                                                                                                                                                           in let _ = "lift2Value checkedHorizon=0"+                                                                                                                                                                               in if ( \( Data.Text.Internal.Text+                                                                                                                                                                                            _+                                                                                                                                                                                            i+                                                                                                                                                                                            _+                                                                                                                                                                                          )+                                                                                                                                                                                        ( Data.Text.Internal.Text+                                                                                                                                                                                            _+                                                                                                                                                                                            j+                                                                                                                                                                                            _+                                                                                                                                                                                          ) -> i GHC.Classes.== j+                                                                                                                                                                                     )+                                                                                                                                                                                    failInp+                                                                                                                                                                                    failInp+                                                                                                                                                                                    then+                                                                                                                                                                                      let _ = "choicesBranch checkedHorizon=0"+                                                                                                                                                                                       in let _ = "catch ExceptionFailure checkedHorizon=0"+                                                                                                                                                                                           in let onException =+                                                                                                                                                                                                    let _ = "onException"+                                                                                                                                                                                                     in \(!_exn) (!failInp) (!farInp) (!farExp) ->+                                                                                                                                                                                                          let _ = "comment: raiseAgainIfConsumed"+                                                                                                                                                                                                           in let _ = "saveInput checkedHorizon=0"+                                                                                                                                                                                                               in let _ = "lift2Value checkedHorizon=0"+                                                                                                                                                                                                                   in if ( \( Data.Text.Internal.Text+                                                                                                                                                                                                                                _+                                                                                                                                                                                                                                i+                                                                                                                                                                                                                                _+                                                                                                                                                                                                                              )+                                                                                                                                                                                                                            ( Data.Text.Internal.Text+                                                                                                                                                                                                                                _+                                                                                                                                                                                                                                j+                                                                                                                                                                                                                                _+                                                                                                                                                                                                                              ) -> i GHC.Classes.== j+                                                                                                                                                                                                                         )+                                                                                                                                                                                                                        failInp+                                                                                                                                                                                                                        failInp+                                                                                                                                                                                                                        then+                                                                                                                                                                                                                          let _ = "choicesBranch checkedHorizon=0"+                                                                                                                                                                                                                           in let _ = "pushValue"+                                                                                                                                                                                                                               in name+                                                                                                                                                                                                                                    ( let _ = "onReturn"+                                                                                                                                                                                                                                       in \farInp farExp v (!inp) ->+                                                                                                                                                                                                                                            let _ = "lift2Value checkedHorizon=0"+                                                                                                                                                                                                                                             in name+                                                                                                                                                                                                                                                  ( let _ = "onReturn"+                                                                                                                                                                                                                                                     in \farInp farExp v (!inp) ->+                                                                                                                                                                                                                                                          let _ = "lift2Value checkedHorizon=0"+                                                                                                                                                                                                                                                           in let _ = "resume"+                                                                                                                                                                                                                                                               in join+                                                                                                                                                                                                                                                                    farInp+                                                                                                                                                                                                                                                                    farExp+                                                                                                                                                                                                                                                                    ( let _ = "resume.genCode"+                                                                                                                                                                                                                                                                       in v+                                                                                                                                                                                                                                                                    )+                                                                                                                                                                                                                                                                    inp+                                                                                                                                                                                                                                                  )+                                                                                                                                                                                                                                                  inp+                                                                                                                                                                                                                                                  (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure (onException callerInput) Data.Map.Internal.Tip Data.Map.Internal.Tip)+                                                                                                                                                                                                                                    )+                                                                                                                                                                                                                                    failInp+                                                                                                                                                                                                                                    (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure (onException callerInput) Data.Map.Internal.Tip Data.Map.Internal.Tip)+                                                                                                                                                                                                                        else+                                                                                                                                                                                                                          let _ = "choicesBranch.else"+                                                                                                                                                                                                                           in onException callerInput Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp farInp farExp+                                                                                                                                                                                               in let _ = "catch ExceptionFailure checkedHorizon=0"+                                                                                                                                                                                                   in let onException =+                                                                                                                                                                                                            let _ = "onException"+                                                                                                                                                                                                             in \(!_exn) (!failInp) (!farInp) (!farExp) ->+                                                                                                                                                                                                                  let _ = "loadInput checkedHorizon=0"+                                                                                                                                                                                                                   in let _ = "checkHorizon.noCheck"+                                                                                                                                                                                                                       in onException Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp farInp farExp+                                                                                                                                                                                                       in let _ = "pushValue"+                                                                                                                                                                                                           in let join = \farInp farExp v (!inp) ->+                                                                                                                                                                                                                    let _ = "lift2Value checkedHorizon=0"+                                                                                                                                                                                                                     in name+                                                                                                                                                                                                                          ( let _ = "onReturn"+                                                                                                                                                                                                                             in \farInp farExp v (!inp) ->+                                                                                                                                                                                                                                  let _ = "lift2Value checkedHorizon=0"+                                                                                                                                                                                                                                   in let _ = "pushValue"+                                                                                                                                                                                                                                       in do+                                                                                                                                                                                                                                            let dupv = \x -> x+                                                                                                                                                                                                                                            reg <- GHC.STRef.newSTRef dupv+                                                                                                                                                                                                                                            let _ = "iter"+                                                                                                                                                                                                                                             in let onException loopInput =+                                                                                                                                                                                                                                                      let _ = "onException"+                                                                                                                                                                                                                                                       in \(!_exn) (!failInp) (!farInp) (!farExp) ->+                                                                                                                                                                                                                                                            let _ = "comment: raiseAgainIfConsumed"+                                                                                                                                                                                                                                                             in let _ = "saveInput checkedHorizon=0"+                                                                                                                                                                                                                                                                 in let _ = "lift2Value checkedHorizon=0"+                                                                                                                                                                                                                                                                     in if ( \( Data.Text.Internal.Text+                                                                                                                                                                                                                                                                                  _+                                                                                                                                                                                                                                                                                  i+                                                                                                                                                                                                                                                                                  _+                                                                                                                                                                                                                                                                                )+                                                                                                                                                                                                                                                                              ( Data.Text.Internal.Text+                                                                                                                                                                                                                                                                                  _+                                                                                                                                                                                                                                                                                  j+                                                                                                                                                                                                                                                                                  _+                                                                                                                                                                                                                                                                                ) -> i GHC.Classes.== j+                                                                                                                                                                                                                                                                           )+                                                                                                                                                                                                                                                                          loopInput+                                                                                                                                                                                                                                                                          failInp+                                                                                                                                                                                                                                                                          then+                                                                                                                                                                                                                                                                            let _ = "choicesBranch checkedHorizon=0"+                                                                                                                                                                                                                                                                             in do+                                                                                                                                                                                                                                                                                  sr <- GHC.STRef.readSTRef reg+                                                                                                                                                                                                                                                                                  name+                                                                                                                                                                                                                                                                                    ( let _ = "onReturn"+                                                                                                                                                                                                                                                                                       in \farInp farExp v (!inp) ->+                                                                                                                                                                                                                                                                                            let _ = "lift2Value checkedHorizon=0"+                                                                                                                                                                                                                                                                                             in let _ = "lift2Value checkedHorizon=0"+                                                                                                                                                                                                                                                                                                 in name+                                                                                                                                                                                                                                                                                                      ( let _ = "onReturn"+                                                                                                                                                                                                                                                                                                         in \farInp farExp v (!inp) ->+                                                                                                                                                                                                                                                                                                              let _ = "lift2Value checkedHorizon=0"+                                                                                                                                                                                                                                                                                                               in let _ = "comment: satisfy ((GHC.Classes.==) '=')"+                                                                                                                                                                                                                                                                                                                   in let inp = inp+                                                                                                                                                                                                                                                                                                                       in let readFail = onException+                                                                                                                                                                                                                                                                                                                           in let _ = "checkHorizon.newCheck: checkedHorizon=0 minHoriz=6"+                                                                                                                                                                                                                                                                                                                               in if readMore (Symantic.Parser.Machine.Input.shiftRightText 5 inp)+                                                                                                                                                                                                                                                                                                                                    then+                                                                                                                                                                                                                                                                                                                                      let _ = "checkToken"+                                                                                                                                                                                                                                                                                                                                       in let !(#+                                                                                                                                                                                                                                                                                                                                                 c,+                                                                                                                                                                                                                                                                                                                                                 cs+                                                                                                                                                                                                                                                                                                                                                 #) = readNext inp+                                                                                                                                                                                                                                                                                                                                           in if (GHC.Classes.==) '=' c+                                                                                                                                                                                                                                                                                                                                                then+                                                                                                                                                                                                                                                                                                                                                  let _ = "lift2Value checkedHorizon=6"+                                                                                                                                                                                                                                                                                                                                                   in name+                                                                                                                                                                                                                                                                                                                                                        ( let _ = "onReturn"+                                                                                                                                                                                                                                                                                                                                                           in \farInp farExp v (!inp) ->+                                                                                                                                                                                                                                                                                                                                                                let _ = "lift2Value checkedHorizon=0"+                                                                                                                                                                                                                                                                                                                                                                 in name+                                                                                                                                                                                                                                                                                                                                                                      ( let _ = "onReturn"+                                                                                                                                                                                                                                                                                                                                                                         in \farInp farExp v (!inp) ->+                                                                                                                                                                                                                                                                                                                                                                              let _ = "lift2Value checkedHorizon=0"+                                                                                                                                                                                                                                                                                                                                                                               in let _ = "pushValue"+                                                                                                                                                                                                                                                                                                                                                                                   in do+                                                                                                                                                                                                                                                                                                                                                                                        let dupv = \x -> x+                                                                                                                                                                                                                                                                                                                                                                                        reg <- GHC.STRef.newSTRef dupv+                                                                                                                                                                                                                                                                                                                                                                                        let _ = "iter"+                                                                                                                                                                                                                                                                                                                                                                                         in let onException loopInput =+                                                                                                                                                                                                                                                                                                                                                                                                  let _ = "onException"+                                                                                                                                                                                                                                                                                                                                                                                                   in \(!_exn) (!failInp) (!farInp) (!farExp) ->+                                                                                                                                                                                                                                                                                                                                                                                                        let _ = "comment: raiseAgainIfConsumed"+                                                                                                                                                                                                                                                                                                                                                                                                         in let _ = "saveInput checkedHorizon=0"+                                                                                                                                                                                                                                                                                                                                                                                                             in let _ = "lift2Value checkedHorizon=0"+                                                                                                                                                                                                                                                                                                                                                                                                                 in if ( \( Data.Text.Internal.Text+                                                                                                                                                                                                                                                                                                                                                                                                                              _+                                                                                                                                                                                                                                                                                                                                                                                                                              i+                                                                                                                                                                                                                                                                                                                                                                                                                              _+                                                                                                                                                                                                                                                                                                                                                                                                                            )+                                                                                                                                                                                                                                                                                                                                                                                                                          ( Data.Text.Internal.Text+                                                                                                                                                                                                                                                                                                                                                                                                                              _+                                                                                                                                                                                                                                                                                                                                                                                                                              j+                                                                                                                                                                                                                                                                                                                                                                                                                              _+                                                                                                                                                                                                                                                                                                                                                                                                                            ) -> i GHC.Classes.== j+                                                                                                                                                                                                                                                                                                                                                                                                                       )+                                                                                                                                                                                                                                                                                                                                                                                                                      loopInput+                                                                                                                                                                                                                                                                                                                                                                                                                      failInp+                                                                                                                                                                                                                                                                                                                                                                                                                      then+                                                                                                                                                                                                                                                                                                                                                                                                                        let _ = "choicesBranch checkedHorizon=0"+                                                                                                                                                                                                                                                                                                                                                                                                                         in do+                                                                                                                                                                                                                                                                                                                                                                                                                              sr <- GHC.STRef.readSTRef reg+                                                                                                                                                                                                                                                                                                                                                                                                                              name+                                                                                                                                                                                                                                                                                                                                                                                                                                ( let _ = "onReturn"+                                                                                                                                                                                                                                                                                                                                                                                                                                   in \farInp farExp v (!inp) ->+                                                                                                                                                                                                                                                                                                                                                                                                                                        let _ = "lift2Value checkedHorizon=0"+                                                                                                                                                                                                                                                                                                                                                                                                                                         in let _ = "lift2Value checkedHorizon=0"+                                                                                                                                                                                                                                                                                                                                                                                                                                             in name+                                                                                                                                                                                                                                                                                                                                                                                                                                                  ( let _ = "onReturn"+                                                                                                                                                                                                                                                                                                                                                                                                                                                     in \farInp farExp v (!inp) ->+                                                                                                                                                                                                                                                                                                                                                                                                                                                          let _ = "lift2Value checkedHorizon=0"+                                                                                                                                                                                                                                                                                                                                                                                                                                                           in name+                                                                                                                                                                                                                                                                                                                                                                                                                                                                ( let _ = "onReturn"+                                                                                                                                                                                                                                                                                                                                                                                                                                                                   in \farInp farExp v (!inp) ->+                                                                                                                                                                                                                                                                                                                                                                                                                                                                        let _ = "lift2Value checkedHorizon=0"+                                                                                                                                                                                                                                                                                                                                                                                                                                                                         in let _ = "commit"+                                                                                                                                                                                                                                                                                                                                                                                                                                                                             in let _ = "commit"+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 in let _ = "resume"+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     in join+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          farInp+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          farExp+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ( let _ = "resume.genCode"+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             in v+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          )+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          inp+                                                                                                                                                                                                                                                                                                                                                                                                                                                                )+                                                                                                                                                                                                                                                                                                                                                                                                                                                                inp+                                                                                                                                                                                                                                                                                                                                                                                                                                                                (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure readFail Data.Map.Internal.Tip Data.Map.Internal.Tip)+                                                                                                                                                                                                                                                                                                                                                                                                                                                  )+                                                                                                                                                                                                                                                                                                                                                                                                                                                  inp+                                                                                                                                                                                                                                                                                                                                                                                                                                                  Data.Map.Internal.Tip+                                                                                                                                                                                                                                                                                                                                                                                                                                )+                                                                                                                                                                                                                                                                                                                                                                                                                                failInp+                                                                                                                                                                                                                                                                                                                                                                                                                                Data.Map.Internal.Tip+                                                                                                                                                                                                                                                                                                                                                                                                                      else+                                                                                                                                                                                                                                                                                                                                                                                                                        let _ = "choicesBranch.else"+                                                                                                                                                                                                                                                                                                                                                                                                                         in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp farInp farExp+                                                                                                                                                                                                                                                                                                                                                                                                loop = \_callerOnReturn callerInput callerOnExceptionStackByLabel ->+                                                                                                                                                                                                                                                                                                                                                                                                  let _ = "pushValue"+                                                                                                                                                                                                                                                                                                                                                                                                   in name+                                                                                                                                                                                                                                                                                                                                                                                                        ( let _ = "onReturn"+                                                                                                                                                                                                                                                                                                                                                                                                           in \farInp farExp v (!inp) ->+                                                                                                                                                                                                                                                                                                                                                                                                                let _ = "lift2Value checkedHorizon=0"+                                                                                                                                                                                                                                                                                                                                                                                                                 in name+                                                                                                                                                                                                                                                                                                                                                                                                                      ( let _ = "onReturn"+                                                                                                                                                                                                                                                                                                                                                                                                                         in \farInp farExp v (!inp) ->+                                                                                                                                                                                                                                                                                                                                                                                                                              let _ = "lift2Value checkedHorizon=0"+                                                                                                                                                                                                                                                                                                                                                                                                                               in name+                                                                                                                                                                                                                                                                                                                                                                                                                                    ( let _ = "onReturn"+                                                                                                                                                                                                                                                                                                                                                                                                                                       in \farInp farExp v (!inp) ->+                                                                                                                                                                                                                                                                                                                                                                                                                                            let _ = "lift2Value checkedHorizon=0"+                                                                                                                                                                                                                                                                                                                                                                                                                                             in do+                                                                                                                                                                                                                                                                                                                                                                                                                                                  sr <- GHC.STRef.readSTRef reg+                                                                                                                                                                                                                                                                                                                                                                                                                                                  let _ = "lift2Value checkedHorizon=0"+                                                                                                                                                                                                                                                                                                                                                                                                                                                   in do+                                                                                                                                                                                                                                                                                                                                                                                                                                                        let dupv = v v sr+                                                                                                                                                                                                                                                                                                                                                                                                                                                        GHC.STRef.writeSTRef reg dupv+                                                                                                                                                                                                                                                                                                                                                                                                                                                        let _ = "jump"+                                                                                                                                                                                                                                                                                                                                                                                                                                                         in loop (GHC.Err.error "invalid onReturn") inp (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure (onException callerInput) Data.Map.Internal.Tip Data.Map.Internal.Tip)+                                                                                                                                                                                                                                                                                                                                                                                                                                    )+                                                                                                                                                                                                                                                                                                                                                                                                                                    inp+                                                                                                                                                                                                                                                                                                                                                                                                                                    (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure (onException callerInput) Data.Map.Internal.Tip Data.Map.Internal.Tip)+                                                                                                                                                                                                                                                                                                                                                                                                                      )+                                                                                                                                                                                                                                                                                                                                                                                                                      inp+                                                                                                                                                                                                                                                                                                                                                                                                                      (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure (onException callerInput) Data.Map.Internal.Tip Data.Map.Internal.Tip)+                                                                                                                                                                                                                                                                                                                                                                                                        )+                                                                                                                                                                                                                                                                                                                                                                                                        callerInput+                                                                                                                                                                                                                                                                                                                                                                                                        Data.Map.Internal.Tip+                                                                                                                                                                                                                                                                                                                                                                                             in let _ = "jump"+                                                                                                                                                                                                                                                                                                                                                                                                 in loop (GHC.Err.error "invalid onReturn") inp (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure readFail Data.Map.Internal.Tip Data.Map.Internal.Tip)+                                                                                                                                                                                                                                                                                                                                                                      )+                                                                                                                                                                                                                                                                                                                                                                      inp+                                                                                                                                                                                                                                                                                                                                                                      (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure readFail Data.Map.Internal.Tip Data.Map.Internal.Tip)+                                                                                                                                                                                                                                                                                                                                                        )+                                                                                                                                                                                                                                                                                                                                                        cs+                                                                                                                                                                                                                                                                                                                                                        (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure readFail Data.Map.Internal.Tip Data.Map.Internal.Tip)+                                                                                                                                                                                                                                                                                                                                                else+                                                                                                                                                                                                                                                                                                                                                  let _ = "checkToken.fail"+                                                                                                                                                                                                                                                                                                                                                   in let failExp =+                                                                                                                                                                                                                                                                                                                                                            Data.Set.Internal.Bin+                                                                                                                                                                                                                                                                                                                                                              1+                                                                                                                                                                                                                                                                                                                                                              ( Symantic.Parser.Grammar.Combinators.SomeFailure+                                                                                                                                                                                                                                                                                                                                                                  ( case inputToken of+                                                                                                                                                                                                                                                                                                                                                                      (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken '='+                                                                                                                                                                                                                                                                                                                                                                  )+                                                                                                                                                                                                                                                                                                                                                              )+                                                                                                                                                                                                                                                                                                                                                              Data.Set.Internal.Tip+                                                                                                                                                                                                                                                                                                                                                              Data.Set.Internal.Tip+                                                                                                                                                                                                                                                                                                                                                       in let (#+                                                                                                                                                                                                                                                                                                                                                                farInp,+                                                                                                                                                                                                                                                                                                                                                                farExp+                                                                                                                                                                                                                                                                                                                                                                #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp inp of+                                                                                                                                                                                                                                                                                                                                                                  GHC.Types.LT ->+                                                                                                                                                                                                                                                                                                                                                                    (#+                                                                                                                                                                                                                                                                                                                                                                      inp,+                                                                                                                                                                                                                                                                                                                                                                      failExp+                                                                                                                                                                                                                                                                                                                                                                    #)+                                                                                                                                                                                                                                                                                                                                                                  GHC.Types.EQ ->+                                                                                                                                                                                                                                                                                                                                                                    (#+                                                                                                                                                                                                                                                                                                                                                                      farInp,+                                                                                                                                                                                                                                                                                                                                                                      failExp GHC.Base.<> farExp+                                                                                                                                                                                                                                                                                                                                                                    #)+                                                                                                                                                                                                                                                                                                                                                                  GHC.Types.GT ->+                                                                                                                                                                                                                                                                                                                                                                    (#+                                                                                                                                                                                                                                                                                                                                                                      farInp,+                                                                                                                                                                                                                                                                                                                                                                      farExp+                                                                                                                                                                                                                                                                                                                                                                    #)+                                                                                                                                                                                                                                                                                                                                                           in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp+                                                                                                                                                                                                                                                                                                                                    else+                                                                                                                                                                                                                                                                                                                                      let _ = "checkHorizon.newCheck.fail"+                                                                                                                                                                                                                                                                                                                                       in let failExp =+                                                                                                                                                                                                                                                                                                                                                Data.Set.Internal.Bin+                                                                                                                                                                                                                                                                                                                                                  1+                                                                                                                                                                                                                                                                                                                                                  ( Symantic.Parser.Grammar.Combinators.SomeFailure+                                                                                                                                                                                                                                                                                                                                                      ( case inputToken of+                                                                                                                                                                                                                                                                                                                                                          (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureHorizon @tok' 6+                                                                                                                                                                                                                                                                                                                                                      )+                                                                                                                                                                                                                                                                                                                                                  )+                                                                                                                                                                                                                                                                                                                                                  Data.Set.Internal.Tip+                                                                                                                                                                                                                                                                                                                                                  Data.Set.Internal.Tip+                                                                                                                                                                                                                                                                                                                                           in let (#+                                                                                                                                                                                                                                                                                                                                                    farInp,+                                                                                                                                                                                                                                                                                                                                                    farExp+                                                                                                                                                                                                                                                                                                                                                    #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp inp of+                                                                                                                                                                                                                                                                                                                                                      GHC.Types.LT ->+                                                                                                                                                                                                                                                                                                                                                        (#+                                                                                                                                                                                                                                                                                                                                                          inp,+                                                                                                                                                                                                                                                                                                                                                          failExp+                                                                                                                                                                                                                                                                                                                                                        #)+                                                                                                                                                                                                                                                                                                                                                      GHC.Types.EQ ->+                                                                                                                                                                                                                                                                                                                                                        (#+                                                                                                                                                                                                                                                                                                                                                          farInp,+                                                                                                                                                                                                                                                                                                                                                          failExp GHC.Base.<> farExp+                                                                                                                                                                                                                                                                                                                                                        #)+                                                                                                                                                                                                                                                                                                                                                      GHC.Types.GT ->+                                                                                                                                                                                                                                                                                                                                                        (#+                                                                                                                                                                                                                                                                                                                                                          farInp,+                                                                                                                                                                                                                                                                                                                                                          farExp+                                                                                                                                                                                                                                                                                                                                                        #)+                                                                                                                                                                                                                                                                                                                                               in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp+                                                                                                                                                                                                                                                                                                      )+                                                                                                                                                                                                                                                                                                      inp+                                                                                                                                                                                                                                                                                                      Data.Map.Internal.Tip+                                                                                                                                                                                                                                                                                    )+                                                                                                                                                                                                                                                                                    failInp+                                                                                                                                                                                                                                                                                    Data.Map.Internal.Tip+                                                                                                                                                                                                                                                                          else+                                                                                                                                                                                                                                                                            let _ = "choicesBranch.else"+                                                                                                                                                                                                                                                                             in onException Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp farInp farExp+                                                                                                                                                                                                                                                    loop = \_callerOnReturn callerInput callerOnExceptionStackByLabel ->+                                                                                                                                                                                                                                                      let _ = "pushValue"+                                                                                                                                                                                                                                                       in name+                                                                                                                                                                                                                                                            ( let _ = "onReturn"+                                                                                                                                                                                                                                                               in \farInp farExp v (!inp) ->+                                                                                                                                                                                                                                                                    let _ = "lift2Value checkedHorizon=0"+                                                                                                                                                                                                                                                                     in name+                                                                                                                                                                                                                                                                          ( let _ = "onReturn"+                                                                                                                                                                                                                                                                             in \farInp farExp v (!inp) ->+                                                                                                                                                                                                                                                                                  let _ = "lift2Value checkedHorizon=0"+                                                                                                                                                                                                                                                                                   in name+                                                                                                                                                                                                                                                                                        ( let _ = "onReturn"+                                                                                                                                                                                                                                                                                           in \farInp farExp v (!inp) ->+                                                                                                                                                                                                                                                                                                let _ = "lift2Value checkedHorizon=0"+                                                                                                                                                                                                                                                                                                 in do+                                                                                                                                                                                                                                                                                                      sr <- GHC.STRef.readSTRef reg+                                                                                                                                                                                                                                                                                                      let _ = "lift2Value checkedHorizon=0"+                                                                                                                                                                                                                                                                                                       in do+                                                                                                                                                                                                                                                                                                            let dupv = v v sr+                                                                                                                                                                                                                                                                                                            GHC.STRef.writeSTRef reg dupv+                                                                                                                                                                                                                                                                                                            let _ = "jump"+                                                                                                                                                                                                                                                                                                             in loop (GHC.Err.error "invalid onReturn") inp (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure (onException callerInput) Data.Map.Internal.Tip Data.Map.Internal.Tip)+                                                                                                                                                                                                                                                                                        )+                                                                                                                                                                                                                                                                                        inp+                                                                                                                                                                                                                                                                                        (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure (onException callerInput) Data.Map.Internal.Tip Data.Map.Internal.Tip)+                                                                                                                                                                                                                                                                          )+                                                                                                                                                                                                                                                                          inp+                                                                                                                                                                                                                                                                          (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure (onException callerInput) Data.Map.Internal.Tip Data.Map.Internal.Tip)+                                                                                                                                                                                                                                                            )+                                                                                                                                                                                                                                                            callerInput+                                                                                                                                                                                                                                                            Data.Map.Internal.Tip+                                                                                                                                                                                                                                                 in let _ = "jump"+                                                                                                                                                                                                                                                     in loop (GHC.Err.error "invalid onReturn") inp (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure onException Data.Map.Internal.Tip Data.Map.Internal.Tip)+                                                                                                                                                                                                                          )+                                                                                                                                                                                                                          inp+                                                                                                                                                                                                                          (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure onException Data.Map.Internal.Tip Data.Map.Internal.Tip)+                                                                                                                                                                                                               in let _ = "catch ExceptionFailure checkedHorizon=0"+                                                                                                                                                                                                                   in let onException =+                                                                                                                                                                                                                            let _ = "onException"+                                                                                                                                                                                                                             in \(!_exn) (!failInp) (!farInp) (!farExp) ->+                                                                                                                                                                                                                                  let _ = "comment: raiseAgainIfConsumed"+                                                                                                                                                                                                                                   in let _ = "saveInput checkedHorizon=0"+                                                                                                                                                                                                                                       in let _ = "lift2Value checkedHorizon=0"+                                                                                                                                                                                                                                           in if ( \( Data.Text.Internal.Text+                                                                                                                                                                                                                                                        _+                                                                                                                                                                                                                                                        i+                                                                                                                                                                                                                                                        _+                                                                                                                                                                                                                                                      )+                                                                                                                                                                                                                                                    ( Data.Text.Internal.Text+                                                                                                                                                                                                                                                        _+                                                                                                                                                                                                                                                        j+                                                                                                                                                                                                                                                        _+                                                                                                                                                                                                                                                      ) -> i GHC.Classes.== j+                                                                                                                                                                                                                                                 )+                                                                                                                                                                                                                                                failInp+                                                                                                                                                                                                                                                failInp+                                                                                                                                                                                                                                                then+                                                                                                                                                                                                                                                  let _ = "choicesBranch checkedHorizon=0"+                                                                                                                                                                                                                                                   in name+                                                                                                                                                                                                                                                        ( let _ = "onReturn"+                                                                                                                                                                                                                                                           in \farInp farExp v (!inp) ->+                                                                                                                                                                                                                                                                let _ = "resume"+                                                                                                                                                                                                                                                                 in join+                                                                                                                                                                                                                                                                      farInp+                                                                                                                                                                                                                                                                      farExp+                                                                                                                                                                                                                                                                      ( let _ = "resume.genCode"+                                                                                                                                                                                                                                                                         in v+                                                                                                                                                                                                                                                                      )+                                                                                                                                                                                                                                                                      inp+                                                                                                                                                                                                                                                        )+                                                                                                                                                                                                                                                        failInp+                                                                                                                                                                                                                                                        Data.Map.Internal.Tip+                                                                                                                                                                                                                                                else+                                                                                                                                                                                                                                                  let _ = "choicesBranch.else"+                                                                                                                                                                                                                                                   in onException Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp farInp farExp+                                                                                                                                                                                                                       in let _ = "pushValue"+                                                                                                                                                                                                                           in let _ = "catch ExceptionFailure checkedHorizon=0"+                                                                                                                                                                                                                               in let onException =+                                                                                                                                                                                                                                        let _ = "onException"+                                                                                                                                                                                                                                         in \(!_exn) (!failInp) (!farInp) (!farExp) ->+                                                                                                                                                                                                                                              let _ = "loadInput checkedHorizon=0"+                                                                                                                                                                                                                                               in let _ = "checkHorizon.noCheck"+                                                                                                                                                                                                                                                   in onException Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp farInp farExp+                                                                                                                                                                                                                                   in let _ = "pushValue"+                                                                                                                                                                                                                                       in let _ = "comment: satisfy ((GHC.Classes.==) 'v')"+                                                                                                                                                                                                                                           in let inp = failInp+                                                                                                                                                                                                                                               in let readFail = onException+                                                                                                                                                                                                                                                   in let _ = "checkHorizon.newCheck: checkedHorizon=0 minHoriz=11"+                                                                                                                                                                                                                                                       in if readMore (Symantic.Parser.Machine.Input.shiftRightText 10 inp)+                                                                                                                                                                                                                                                            then+                                                                                                                                                                                                                                                              let _ = "checkToken"+                                                                                                                                                                                                                                                               in let !(#+                                                                                                                                                                                                                                                                         c,+                                                                                                                                                                                                                                                                         cs+                                                                                                                                                                                                                                                                         #) = readNext inp+                                                                                                                                                                                                                                                                   in if (GHC.Classes.==) 'v' c+                                                                                                                                                                                                                                                                        then+                                                                                                                                                                                                                                                                          let _ = "lift2Value checkedHorizon=11"+                                                                                                                                                                                                                                                                           in let _ = "comment: satisfy ((GHC.Classes.==) 'a')"+                                                                                                                                                                                                                                                                               in let _ = "checkHorizon.oldCheck: checkedHorizon=11"+                                                                                                                                                                                                                                                                                   in let _ = "checkToken"+                                                                                                                                                                                                                                                                                       in let !(#+                                                                                                                                                                                                                                                                                                 c,+                                                                                                                                                                                                                                                                                                 cs+                                                                                                                                                                                                                                                                                                 #) = readNext cs+                                                                                                                                                                                                                                                                                           in if (GHC.Classes.==) 'a' c+                                                                                                                                                                                                                                                                                                then+                                                                                                                                                                                                                                                                                                  let _ = "lift2Value checkedHorizon=10"+                                                                                                                                                                                                                                                                                                   in let _ = "comment: satisfy ((GHC.Classes.==) 'r')"+                                                                                                                                                                                                                                                                                                       in let _ = "checkHorizon.oldCheck: checkedHorizon=10"+                                                                                                                                                                                                                                                                                                           in let _ = "checkToken"+                                                                                                                                                                                                                                                                                                               in let !(#+                                                                                                                                                                                                                                                                                                                         c,+                                                                                                                                                                                                                                                                                                                         cs+                                                                                                                                                                                                                                                                                                                         #) = readNext cs+                                                                                                                                                                                                                                                                                                                   in if (GHC.Classes.==) 'r' c+                                                                                                                                                                                                                                                                                                                        then+                                                                                                                                                                                                                                                                                                                          let _ = "lift2Value checkedHorizon=9"+                                                                                                                                                                                                                                                                                                                           in let _ = "commit"+                                                                                                                                                                                                                                                                                                                               in let _ = "lift2Value checkedHorizon=9"+                                                                                                                                                                                                                                                                                                                                   in name+                                                                                                                                                                                                                                                                                                                                        ( let _ = "onReturn"+                                                                                                                                                                                                                                                                                                                                           in \farInp farExp v (!inp) ->+                                                                                                                                                                                                                                                                                                                                                let _ = "lift2Value checkedHorizon=0"+                                                                                                                                                                                                                                                                                                                                                 in let _ = "commit"+                                                                                                                                                                                                                                                                                                                                                     in let _ = "resume"+                                                                                                                                                                                                                                                                                                                                                         in join+                                                                                                                                                                                                                                                                                                                                                              farInp+                                                                                                                                                                                                                                                                                                                                                              farExp+                                                                                                                                                                                                                                                                                                                                                              ( let _ = "resume.genCode"+                                                                                                                                                                                                                                                                                                                                                                 in GHC.Tuple . ()+                                                                                                                                                                                                                                                                                                                                                              )+                                                                                                                                                                                                                                                                                                                                                              inp+                                                                                                                                                                                                                                                                                                                                        )+                                                                                                                                                                                                                                                                                                                                        cs+                                                                                                                                                                                                                                                                                                                                        Data.Map.Internal.Tip+                                                                                                                                                                                                                                                                                                                        else+                                                                                                                                                                                                                                                                                                                          let _ = "checkToken.fail"+                                                                                                                                                                                                                                                                                                                           in let failExp =+                                                                                                                                                                                                                                                                                                                                    Data.Set.Internal.Bin+                                                                                                                                                                                                                                                                                                                                      1+                                                                                                                                                                                                                                                                                                                                      ( Symantic.Parser.Grammar.Combinators.SomeFailure+                                                                                                                                                                                                                                                                                                                                          ( case inputToken of+                                                                                                                                                                                                                                                                                                                                              (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken 'r'+                                                                                                                                                                                                                                                                                                                                          )+                                                                                                                                                                                                                                                                                                                                      )+                                                                                                                                                                                                                                                                                                                                      Data.Set.Internal.Tip+                                                                                                                                                                                                                                                                                                                                      Data.Set.Internal.Tip+                                                                                                                                                                                                                                                                                                                               in let (#+                                                                                                                                                                                                                                                                                                                                        farInp,+                                                                                                                                                                                                                                                                                                                                        farExp+                                                                                                                                                                                                                                                                                                                                        #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp cs of+                                                                                                                                                                                                                                                                                                                                          GHC.Types.LT ->+                                                                                                                                                                                                                                                                                                                                            (#+                                                                                                                                                                                                                                                                                                                                              cs,+                                                                                                                                                                                                                                                                                                                                              failExp+                                                                                                                                                                                                                                                                                                                                            #)+                                                                                                                                                                                                                                                                                                                                          GHC.Types.EQ ->+                                                                                                                                                                                                                                                                                                                                            (#+                                                                                                                                                                                                                                                                                                                                              farInp,+                                                                                                                                                                                                                                                                                                                                              failExp GHC.Base.<> farExp+                                                                                                                                                                                                                                                                                                                                            #)+                                                                                                                                                                                                                                                                                                                                          GHC.Types.GT ->+                                                                                                                                                                                                                                                                                                                                            (#+                                                                                                                                                                                                                                                                                                                                              farInp,+                                                                                                                                                                                                                                                                                                                                              farExp+                                                                                                                                                                                                                                                                                                                                            #)+                                                                                                                                                                                                                                                                                                                                   in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure cs farInp farExp+                                                                                                                                                                                                                                                                                                else+                                                                                                                                                                                                                                                                                                  let _ = "checkToken.fail"+                                                                                                                                                                                                                                                                                                   in let failExp =+                                                                                                                                                                                                                                                                                                            Data.Set.Internal.Bin+                                                                                                                                                                                                                                                                                                              1+                                                                                                                                                                                                                                                                                                              ( Symantic.Parser.Grammar.Combinators.SomeFailure+                                                                                                                                                                                                                                                                                                                  ( case inputToken of+                                                                                                                                                                                                                                                                                                                      (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken 'a'+                                                                                                                                                                                                                                                                                                                  )+                                                                                                                                                                                                                                                                                                              )+                                                                                                                                                                                                                                                                                                              Data.Set.Internal.Tip+                                                                                                                                                                                                                                                                                                              Data.Set.Internal.Tip+                                                                                                                                                                                                                                                                                                       in let (#+                                                                                                                                                                                                                                                                                                                farInp,+                                                                                                                                                                                                                                                                                                                farExp+                                                                                                                                                                                                                                                                                                                #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp cs of+                                                                                                                                                                                                                                                                                                                  GHC.Types.LT ->+                                                                                                                                                                                                                                                                                                                    (#+                                                                                                                                                                                                                                                                                                                      cs,+                                                                                                                                                                                                                                                                                                                      failExp+                                                                                                                                                                                                                                                                                                                    #)+                                                                                                                                                                                                                                                                                                                  GHC.Types.EQ ->+                                                                                                                                                                                                                                                                                                                    (#+                                                                                                                                                                                                                                                                                                                      farInp,+                                                                                                                                                                                                                                                                                                                      failExp GHC.Base.<> farExp+                                                                                                                                                                                                                                                                                                                    #)+                                                                                                                                                                                                                                                                                                                  GHC.Types.GT ->+                                                                                                                                                                                                                                                                                                                    (#+                                                                                                                                                                                                                                                                                                                      farInp,+                                                                                                                                                                                                                                                                                                                      farExp+                                                                                                                                                                                                                                                                                                                    #)+                                                                                                                                                                                                                                                                                                           in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure cs farInp farExp+                                                                                                                                                                                                                                                                        else+                                                                                                                                                                                                                                                                          let _ = "checkToken.fail"+                                                                                                                                                                                                                                                                           in let failExp =+                                                                                                                                                                                                                                                                                    Data.Set.Internal.Bin+                                                                                                                                                                                                                                                                                      1+                                                                                                                                                                                                                                                                                      ( Symantic.Parser.Grammar.Combinators.SomeFailure+                                                                                                                                                                                                                                                                                          ( case inputToken of+                                                                                                                                                                                                                                                                                              (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken 'v'+                                                                                                                                                                                                                                                                                          )+                                                                                                                                                                                                                                                                                      )+                                                                                                                                                                                                                                                                                      Data.Set.Internal.Tip+                                                                                                                                                                                                                                                                                      Data.Set.Internal.Tip+                                                                                                                                                                                                                                                                               in let (#+                                                                                                                                                                                                                                                                                        farInp,+                                                                                                                                                                                                                                                                                        farExp+                                                                                                                                                                                                                                                                                        #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp inp of+                                                                                                                                                                                                                                                                                          GHC.Types.LT ->+                                                                                                                                                                                                                                                                                            (#+                                                                                                                                                                                                                                                                                              inp,+                                                                                                                                                                                                                                                                                              failExp+                                                                                                                                                                                                                                                                                            #)+                                                                                                                                                                                                                                                                                          GHC.Types.EQ ->+                                                                                                                                                                                                                                                                                            (#+                                                                                                                                                                                                                                                                                              farInp,+                                                                                                                                                                                                                                                                                              failExp GHC.Base.<> farExp+                                                                                                                                                                                                                                                                                            #)+                                                                                                                                                                                                                                                                                          GHC.Types.GT ->+                                                                                                                                                                                                                                                                                            (#+                                                                                                                                                                                                                                                                                              farInp,+                                                                                                                                                                                                                                                                                              farExp+                                                                                                                                                                                                                                                                                            #)+                                                                                                                                                                                                                                                                                   in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp+                                                                                                                                                                                                                                                            else+                                                                                                                                                                                                                                                              let _ = "checkHorizon.newCheck.fail"+                                                                                                                                                                                                                                                               in let failExp =+                                                                                                                                                                                                                                                                        Data.Set.Internal.Bin+                                                                                                                                                                                                                                                                          1+                                                                                                                                                                                                                                                                          ( Symantic.Parser.Grammar.Combinators.SomeFailure+                                                                                                                                                                                                                                                                              ( case inputToken of+                                                                                                                                                                                                                                                                                  (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureHorizon @tok' 11+                                                                                                                                                                                                                                                                              )+                                                                                                                                                                                                                                                                          )+                                                                                                                                                                                                                                                                          Data.Set.Internal.Tip+                                                                                                                                                                                                                                                                          Data.Set.Internal.Tip+                                                                                                                                                                                                                                                                   in let (#+                                                                                                                                                                                                                                                                            farInp,+                                                                                                                                                                                                                                                                            farExp+                                                                                                                                                                                                                                                                            #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp inp of+                                                                                                                                                                                                                                                                              GHC.Types.LT ->+                                                                                                                                                                                                                                                                                (#+                                                                                                                                                                                                                                                                                  inp,+                                                                                                                                                                                                                                                                                  failExp+                                                                                                                                                                                                                                                                                #)+                                                                                                                                                                                                                                                                              GHC.Types.EQ ->+                                                                                                                                                                                                                                                                                (#+                                                                                                                                                                                                                                                                                  farInp,+                                                                                                                                                                                                                                                                                  failExp GHC.Base.<> farExp+                                                                                                                                                                                                                                                                                #)+                                                                                                                                                                                                                                                                              GHC.Types.GT ->+                                                                                                                                                                                                                                                                                (#+                                                                                                                                                                                                                                                                                  farInp,+                                                                                                                                                                                                                                                                                  farExp+                                                                                                                                                                                                                                                                                #)+                                                                                                                                                                                                                                                                       in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp+                                                                                                                                                                                    else+                                                                                                                                                                                      let _ = "choicesBranch.else"+                                                                                                                                                                                       in onException callerInput Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp farInp farExp+                                                                                                                                                           in let _ = "pushValue"+                                                                                                                                                               in let _ = "catch ExceptionFailure checkedHorizon=0"+                                                                                                                                                                   in let onException =+                                                                                                                                                                            let _ = "onException"+                                                                                                                                                                             in \(!_exn) (!failInp) (!farInp) (!farExp) ->+                                                                                                                                                                                  let _ = "loadInput checkedHorizon=0"+                                                                                                                                                                                   in let _ = "checkHorizon.noCheck"+                                                                                                                                                                                       in onException Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp farInp farExp+                                                                                                                                                                       in let _ = "pushValue"+                                                                                                                                                                           in let _ = "comment: satisfy ((GHC.Classes.==) 'w')"+                                                                                                                                                                               in let inp = failInp+                                                                                                                                                                                   in let readFail = onException+                                                                                                                                                                                       in let _ = "checkHorizon.newCheck: checkedHorizon=0 minHoriz=7"+                                                                                                                                                                                           in if readMore (Symantic.Parser.Machine.Input.shiftRightText 6 inp)+                                                                                                                                                                                                then+                                                                                                                                                                                                  let _ = "checkToken"+                                                                                                                                                                                                   in let !(#+                                                                                                                                                                                                             c,+                                                                                                                                                                                                             cs+                                                                                                                                                                                                             #) = readNext inp+                                                                                                                                                                                                       in if (GHC.Classes.==) 'w' c+                                                                                                                                                                                                            then+                                                                                                                                                                                                              let _ = "lift2Value checkedHorizon=7"+                                                                                                                                                                                                               in let _ = "comment: satisfy ((GHC.Classes.==) 'h')"+                                                                                                                                                                                                                   in let _ = "checkHorizon.oldCheck: checkedHorizon=7"+                                                                                                                                                                                                                       in let _ = "checkToken"+                                                                                                                                                                                                                           in let !(#+                                                                                                                                                                                                                                     c,+                                                                                                                                                                                                                                     cs+                                                                                                                                                                                                                                     #) = readNext cs+                                                                                                                                                                                                                               in if (GHC.Classes.==) 'h' c+                                                                                                                                                                                                                                    then+                                                                                                                                                                                                                                      let _ = "lift2Value checkedHorizon=6"+                                                                                                                                                                                                                                       in let _ = "comment: satisfy ((GHC.Classes.==) 'i')"+                                                                                                                                                                                                                                           in let _ = "checkHorizon.oldCheck: checkedHorizon=6"+                                                                                                                                                                                                                                               in let _ = "checkToken"+                                                                                                                                                                                                                                                   in let !(#+                                                                                                                                                                                                                                                             c,+                                                                                                                                                                                                                                                             cs+                                                                                                                                                                                                                                                             #) = readNext cs+                                                                                                                                                                                                                                                       in if (GHC.Classes.==) 'i' c+                                                                                                                                                                                                                                                            then+                                                                                                                                                                                                                                                              let _ = "lift2Value checkedHorizon=5"+                                                                                                                                                                                                                                                               in let _ = "comment: satisfy ((GHC.Classes.==) 'l')"+                                                                                                                                                                                                                                                                   in let _ = "checkHorizon.oldCheck: checkedHorizon=5"+                                                                                                                                                                                                                                                                       in let _ = "checkToken"+                                                                                                                                                                                                                                                                           in let !(#+                                                                                                                                                                                                                                                                                     c,+                                                                                                                                                                                                                                                                                     cs+                                                                                                                                                                                                                                                                                     #) = readNext cs+                                                                                                                                                                                                                                                                               in if (GHC.Classes.==) 'l' c+                                                                                                                                                                                                                                                                                    then+                                                                                                                                                                                                                                                                                      let _ = "lift2Value checkedHorizon=4"+                                                                                                                                                                                                                                                                                       in let _ = "comment: satisfy ((GHC.Classes.==) 'e')"+                                                                                                                                                                                                                                                                                           in let _ = "checkHorizon.oldCheck: checkedHorizon=4"+                                                                                                                                                                                                                                                                                               in let _ = "checkToken"+                                                                                                                                                                                                                                                                                                   in let !(#+                                                                                                                                                                                                                                                                                                             c,+                                                                                                                                                                                                                                                                                                             cs+                                                                                                                                                                                                                                                                                                             #) = readNext cs+                                                                                                                                                                                                                                                                                                       in if (GHC.Classes.==) 'e' c+                                                                                                                                                                                                                                                                                                            then+                                                                                                                                                                                                                                                                                                              let _ = "lift2Value checkedHorizon=3"+                                                                                                                                                                                                                                                                                                               in let _ = "commit"+                                                                                                                                                                                                                                                                                                                   in let _ = "lift2Value checkedHorizon=3"+                                                                                                                                                                                                                                                                                                                       in name+                                                                                                                                                                                                                                                                                                                            ( let _ = "onReturn"+                                                                                                                                                                                                                                                                                                                               in \farInp farExp v (!inp) ->+                                                                                                                                                                                                                                                                                                                                    let _ = "lift2Value checkedHorizon=0"+                                                                                                                                                                                                                                                                                                                                     in name+                                                                                                                                                                                                                                                                                                                                          ( let _ = "onReturn"+                                                                                                                                                                                                                                                                                                                                             in \farInp farExp v (!inp) ->+                                                                                                                                                                                                                                                                                                                                                  let _ = "lift2Value checkedHorizon=0"+                                                                                                                                                                                                                                                                                                                                                   in name+                                                                                                                                                                                                                                                                                                                                                        ( let _ = "onReturn"+                                                                                                                                                                                                                                                                                                                                                           in \farInp farExp v (!inp) ->+                                                                                                                                                                                                                                                                                                                                                                let _ = "lift2Value checkedHorizon=0"+                                                                                                                                                                                                                                                                                                                                                                 in let _ = "commit"+                                                                                                                                                                                                                                                                                                                                                                     in let _ = "resume"+                                                                                                                                                                                                                                                                                                                                                                         in join+                                                                                                                                                                                                                                                                                                                                                                              farInp+                                                                                                                                                                                                                                                                                                                                                                              farExp+                                                                                                                                                                                                                                                                                                                                                                              ( let _ = "resume.genCode"+                                                                                                                                                                                                                                                                                                                                                                                 in v+                                                                                                                                                                                                                                                                                                                                                                              )+                                                                                                                                                                                                                                                                                                                                                                              inp+                                                                                                                                                                                                                                                                                                                                                        )+                                                                                                                                                                                                                                                                                                                                                        inp+                                                                                                                                                                                                                                                                                                                                                        (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure onException Data.Map.Internal.Tip Data.Map.Internal.Tip)+                                                                                                                                                                                                                                                                                                                                          )+                                                                                                                                                                                                                                                                                                                                          inp+                                                                                                                                                                                                                                                                                                                                          (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure onException Data.Map.Internal.Tip Data.Map.Internal.Tip)+                                                                                                                                                                                                                                                                                                                            )+                                                                                                                                                                                                                                                                                                                            cs+                                                                                                                                                                                                                                                                                                                            Data.Map.Internal.Tip+                                                                                                                                                                                                                                                                                                            else+                                                                                                                                                                                                                                                                                                              let _ = "checkToken.fail"+                                                                                                                                                                                                                                                                                                               in let failExp =+                                                                                                                                                                                                                                                                                                                        Data.Set.Internal.Bin+                                                                                                                                                                                                                                                                                                                          1+                                                                                                                                                                                                                                                                                                                          ( Symantic.Parser.Grammar.Combinators.SomeFailure+                                                                                                                                                                                                                                                                                                                              ( case inputToken of+                                                                                                                                                                                                                                                                                                                                  (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken 'e'+                                                                                                                                                                                                                                                                                                                              )+                                                                                                                                                                                                                                                                                                                          )+                                                                                                                                                                                                                                                                                                                          Data.Set.Internal.Tip+                                                                                                                                                                                                                                                                                                                          Data.Set.Internal.Tip+                                                                                                                                                                                                                                                                                                                   in let (#+                                                                                                                                                                                                                                                                                                                            farInp,+                                                                                                                                                                                                                                                                                                                            farExp+                                                                                                                                                                                                                                                                                                                            #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp cs of+                                                                                                                                                                                                                                                                                                                              GHC.Types.LT ->+                                                                                                                                                                                                                                                                                                                                (#+                                                                                                                                                                                                                                                                                                                                  cs,+                                                                                                                                                                                                                                                                                                                                  failExp+                                                                                                                                                                                                                                                                                                                                #)+                                                                                                                                                                                                                                                                                                                              GHC.Types.EQ ->+                                                                                                                                                                                                                                                                                                                                (#+                                                                                                                                                                                                                                                                                                                                  farInp,+                                                                                                                                                                                                                                                                                                                                  failExp GHC.Base.<> farExp+                                                                                                                                                                                                                                                                                                                                #)+                                                                                                                                                                                                                                                                                                                              GHC.Types.GT ->+                                                                                                                                                                                                                                                                                                                                (#+                                                                                                                                                                                                                                                                                                                                  farInp,+                                                                                                                                                                                                                                                                                                                                  farExp+                                                                                                                                                                                                                                                                                                                                #)+                                                                                                                                                                                                                                                                                                                       in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure cs farInp farExp+                                                                                                                                                                                                                                                                                    else+                                                                                                                                                                                                                                                                                      let _ = "checkToken.fail"+                                                                                                                                                                                                                                                                                       in let failExp =+                                                                                                                                                                                                                                                                                                Data.Set.Internal.Bin+                                                                                                                                                                                                                                                                                                  1+                                                                                                                                                                                                                                                                                                  ( Symantic.Parser.Grammar.Combinators.SomeFailure+                                                                                                                                                                                                                                                                                                      ( case inputToken of+                                                                                                                                                                                                                                                                                                          (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken 'l'+                                                                                                                                                                                                                                                                                                      )+                                                                                                                                                                                                                                                                                                  )+                                                                                                                                                                                                                                                                                                  Data.Set.Internal.Tip+                                                                                                                                                                                                                                                                                                  Data.Set.Internal.Tip+                                                                                                                                                                                                                                                                                           in let (#+                                                                                                                                                                                                                                                                                                    farInp,+                                                                                                                                                                                                                                                                                                    farExp+                                                                                                                                                                                                                                                                                                    #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp cs of+                                                                                                                                                                                                                                                                                                      GHC.Types.LT ->+                                                                                                                                                                                                                                                                                                        (#+                                                                                                                                                                                                                                                                                                          cs,+                                                                                                                                                                                                                                                                                                          failExp+                                                                                                                                                                                                                                                                                                        #)+                                                                                                                                                                                                                                                                                                      GHC.Types.EQ ->+                                                                                                                                                                                                                                                                                                        (#+                                                                                                                                                                                                                                                                                                          farInp,+                                                                                                                                                                                                                                                                                                          failExp GHC.Base.<> farExp+                                                                                                                                                                                                                                                                                                        #)+                                                                                                                                                                                                                                                                                                      GHC.Types.GT ->+                                                                                                                                                                                                                                                                                                        (#+                                                                                                                                                                                                                                                                                                          farInp,+                                                                                                                                                                                                                                                                                                          farExp+                                                                                                                                                                                                                                                                                                        #)+                                                                                                                                                                                                                                                                                               in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure cs farInp farExp+                                                                                                                                                                                                                                                            else+                                                                                                                                                                                                                                                              let _ = "checkToken.fail"+                                                                                                                                                                                                                                                               in let failExp =+                                                                                                                                                                                                                                                                        Data.Set.Internal.Bin+                                                                                                                                                                                                                                                                          1+                                                                                                                                                                                                                                                                          ( Symantic.Parser.Grammar.Combinators.SomeFailure+                                                                                                                                                                                                                                                                              ( case inputToken of+                                                                                                                                                                                                                                                                                  (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken 'i'+                                                                                                                                                                                                                                                                              )+                                                                                                                                                                                                                                                                          )+                                                                                                                                                                                                                                                                          Data.Set.Internal.Tip+                                                                                                                                                                                                                                                                          Data.Set.Internal.Tip+                                                                                                                                                                                                                                                                   in let (#+                                                                                                                                                                                                                                                                            farInp,+                                                                                                                                                                                                                                                                            farExp+                                                                                                                                                                                                                                                                            #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp cs of+                                                                                                                                                                                                                                                                              GHC.Types.LT ->+                                                                                                                                                                                                                                                                                (#+                                                                                                                                                                                                                                                                                  cs,+                                                                                                                                                                                                                                                                                  failExp+                                                                                                                                                                                                                                                                                #)+                                                                                                                                                                                                                                                                              GHC.Types.EQ ->+                                                                                                                                                                                                                                                                                (#+                                                                                                                                                                                                                                                                                  farInp,+                                                                                                                                                                                                                                                                                  failExp GHC.Base.<> farExp+                                                                                                                                                                                                                                                                                #)+                                                                                                                                                                                                                                                                              GHC.Types.GT ->+                                                                                                                                                                                                                                                                                (#+                                                                                                                                                                                                                                                                                  farInp,+                                                                                                                                                                                                                                                                                  farExp+                                                                                                                                                                                                                                                                                #)+                                                                                                                                                                                                                                                                       in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure cs farInp farExp+                                                                                                                                                                                                                                    else+                                                                                                                                                                                                                                      let _ = "checkToken.fail"+                                                                                                                                                                                                                                       in let failExp =+                                                                                                                                                                                                                                                Data.Set.Internal.Bin+                                                                                                                                                                                                                                                  1+                                                                                                                                                                                                                                                  ( Symantic.Parser.Grammar.Combinators.SomeFailure+                                                                                                                                                                                                                                                      ( case inputToken of+                                                                                                                                                                                                                                                          (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken 'h'+                                                                                                                                                                                                                                                      )+                                                                                                                                                                                                                                                  )+                                                                                                                                                                                                                                                  Data.Set.Internal.Tip+                                                                                                                                                                                                                                                  Data.Set.Internal.Tip+                                                                                                                                                                                                                                           in let (#+                                                                                                                                                                                                                                                    farInp,+                                                                                                                                                                                                                                                    farExp+                                                                                                                                                                                                                                                    #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp cs of+                                                                                                                                                                                                                                                      GHC.Types.LT ->+                                                                                                                                                                                                                                                        (#+                                                                                                                                                                                                                                                          cs,+                                                                                                                                                                                                                                                          failExp+                                                                                                                                                                                                                                                        #)+                                                                                                                                                                                                                                                      GHC.Types.EQ ->+                                                                                                                                                                                                                                                        (#+                                                                                                                                                                                                                                                          farInp,+                                                                                                                                                                                                                                                          failExp GHC.Base.<> farExp+                                                                                                                                                                                                                                                        #)+                                                                                                                                                                                                                                                      GHC.Types.GT ->+                                                                                                                                                                                                                                                        (#+                                                                                                                                                                                                                                                          farInp,+                                                                                                                                                                                                                                                          farExp+                                                                                                                                                                                                                                                        #)+                                                                                                                                                                                                                                               in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure cs farInp farExp+                                                                                                                                                                                                            else+                                                                                                                                                                                                              let _ = "checkToken.fail"+                                                                                                                                                                                                               in let failExp =+                                                                                                                                                                                                                        Data.Set.Internal.Bin+                                                                                                                                                                                                                          1+                                                                                                                                                                                                                          ( Symantic.Parser.Grammar.Combinators.SomeFailure+                                                                                                                                                                                                                              ( case inputToken of+                                                                                                                                                                                                                                  (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken 'w'+                                                                                                                                                                                                                              )+                                                                                                                                                                                                                          )+                                                                                                                                                                                                                          Data.Set.Internal.Tip+                                                                                                                                                                                                                          Data.Set.Internal.Tip+                                                                                                                                                                                                                   in let (#+                                                                                                                                                                                                                            farInp,+                                                                                                                                                                                                                            farExp+                                                                                                                                                                                                                            #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp inp of+                                                                                                                                                                                                                              GHC.Types.LT ->+                                                                                                                                                                                                                                (#+                                                                                                                                                                                                                                  inp,+                                                                                                                                                                                                                                  failExp+                                                                                                                                                                                                                                #)+                                                                                                                                                                                                                              GHC.Types.EQ ->+                                                                                                                                                                                                                                (#+                                                                                                                                                                                                                                  farInp,+                                                                                                                                                                                                                                  failExp GHC.Base.<> farExp+                                                                                                                                                                                                                                #)+                                                                                                                                                                                                                              GHC.Types.GT ->+                                                                                                                                                                                                                                (#+                                                                                                                                                                                                                                  farInp,+                                                                                                                                                                                                                                  farExp+                                                                                                                                                                                                                                #)+                                                                                                                                                                                                                       in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp+                                                                                                                                                                                                else+                                                                                                                                                                                                  let _ = "checkHorizon.newCheck.fail"+                                                                                                                                                                                                   in let failExp =+                                                                                                                                                                                                            Data.Set.Internal.Bin+                                                                                                                                                                                                              1+                                                                                                                                                                                                              ( Symantic.Parser.Grammar.Combinators.SomeFailure+                                                                                                                                                                                                                  ( case inputToken of+                                                                                                                                                                                                                      (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureHorizon @tok' 7+                                                                                                                                                                                                                  )+                                                                                                                                                                                                              )+                                                                                                                                                                                                              Data.Set.Internal.Tip+                                                                                                                                                                                                              Data.Set.Internal.Tip+                                                                                                                                                                                                       in let (#+                                                                                                                                                                                                                farInp,+                                                                                                                                                                                                                farExp+                                                                                                                                                                                                                #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp inp of+                                                                                                                                                                                                                  GHC.Types.LT ->+                                                                                                                                                                                                                    (#+                                                                                                                                                                                                                      inp,+                                                                                                                                                                                                                      failExp+                                                                                                                                                                                                                    #)+                                                                                                                                                                                                                  GHC.Types.EQ ->+                                                                                                                                                                                                                    (#+                                                                                                                                                                                                                      farInp,+                                                                                                                                                                                                                      failExp GHC.Base.<> farExp+                                                                                                                                                                                                                    #)+                                                                                                                                                                                                                  GHC.Types.GT ->+                                                                                                                                                                                                                    (#+                                                                                                                                                                                                                      farInp,+                                                                                                                                                                                                                      farExp+                                                                                                                                                                                                                    #)+                                                                                                                                                                                                           in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp+                                                                                                                                                else+                                                                                                                                                  let _ = "choicesBranch.else"+                                                                                                                                                   in onException callerInput Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp farInp farExp+                                                                                                                       in let _ = "pushValue"+                                                                                                                           in let _ = "catch ExceptionFailure checkedHorizon=0"+                                                                                                                               in let onException =+                                                                                                                                        let _ = "onException"+                                                                                                                                         in \(!_exn) (!failInp) (!farInp) (!farExp) ->+                                                                                                                                              let _ = "loadInput checkedHorizon=0"+                                                                                                                                               in let _ = "checkHorizon.noCheck"+                                                                                                                                                   in onException Symantic.Parser.Grammar.Combinators.ExceptionFailure callerInput farInp farExp+                                                                                                                                   in let _ = "pushValue"+                                                                                                                                       in let _ = "comment: satisfy ((GHC.Classes.==) 'i')"+                                                                                                                                           in let inp = callerInput+                                                                                                                                               in let readFail = onException+                                                                                                                                                   in let _ = "checkHorizon.newCheck: checkedHorizon=0 minHoriz=2"+                                                                                                                                                       in if readMore (Symantic.Parser.Machine.Input.shiftRightText 1 inp)+                                                                                                                                                            then+                                                                                                                                                              let _ = "checkToken"+                                                                                                                                                               in let !(#+                                                                                                                                                                         c,+                                                                                                                                                                         cs+                                                                                                                                                                         #) = readNext inp+                                                                                                                                                                   in if (GHC.Classes.==) 'i' c+                                                                                                                                                                        then+                                                                                                                                                                          let _ = "lift2Value checkedHorizon=2"+                                                                                                                                                                           in let _ = "comment: satisfy ((GHC.Classes.==) 'f')"+                                                                                                                                                                               in let _ = "checkHorizon.oldCheck: checkedHorizon=2"+                                                                                                                                                                                   in let _ = "checkToken"+                                                                                                                                                                                       in let !(#+                                                                                                                                                                                                 c,+                                                                                                                                                                                                 cs+                                                                                                                                                                                                 #) = readNext cs+                                                                                                                                                                                           in if (GHC.Classes.==) 'f' c+                                                                                                                                                                                                then+                                                                                                                                                                                                  let _ = "lift2Value checkedHorizon=1"+                                                                                                                                                                                                   in let _ = "commit"+                                                                                                                                                                                                       in let _ = "lift2Value checkedHorizon=1"+                                                                                                                                                                                                           in name+                                                                                                                                                                                                                ( let _ = "onReturn"+                                                                                                                                                                                                                   in \farInp farExp v (!inp) ->+                                                                                                                                                                                                                        let _ = "lift2Value checkedHorizon=0"+                                                                                                                                                                                                                         in let _ = "commit"+                                                                                                                                                                                                                             in let _ = "resume"+                                                                                                                                                                                                                                 in join+                                                                                                                                                                                                                                      farInp+                                                                                                                                                                                                                                      farExp+                                                                                                                                                                                                                                      ( let _ = "resume.genCode"+                                                                                                                                                                                                                                         in v+                                                                                                                                                                                                                                      )+                                                                                                                                                                                                                                      inp+                                                                                                                                                                                                                )+                                                                                                                                                                                                                cs+                                                                                                                                                                                                                Data.Map.Internal.Tip+                                                                                                                                                                                                else+                                                                                                                                                                                                  let _ = "checkToken.fail"+                                                                                                                                                                                                   in let failExp =+                                                                                                                                                                                                            Data.Set.Internal.Bin+                                                                                                                                                                                                              1+                                                                                                                                                                                                              ( Symantic.Parser.Grammar.Combinators.SomeFailure+                                                                                                                                                                                                                  ( case inputToken of+                                                                                                                                                                                                                      (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken 'f'+                                                                                                                                                                                                                  )+                                                                                                                                                                                                              )+                                                                                                                                                                                                              Data.Set.Internal.Tip+                                                                                                                                                                                                              Data.Set.Internal.Tip+                                                                                                                                                                                                       in let (#+                                                                                                                                                                                                                farInp,+                                                                                                                                                                                                                farExp+                                                                                                                                                                                                                #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp cs of+                                                                                                                                                                                                                  GHC.Types.LT ->+                                                                                                                                                                                                                    (#+                                                                                                                                                                                                                      cs,+                                                                                                                                                                                                                      failExp+                                                                                                                                                                                                                    #)+                                                                                                                                                                                                                  GHC.Types.EQ ->+                                                                                                                                                                                                                    (#+                                                                                                                                                                                                                      farInp,+                                                                                                                                                                                                                      failExp GHC.Base.<> farExp+                                                                                                                                                                                                                    #)+                                                                                                                                                                                                                  GHC.Types.GT ->+                                                                                                                                                                                                                    (#+                                                                                                                                                                                                                      farInp,+                                                                                                                                                                                                                      farExp+                                                                                                                                                                                                                    #)+                                                                                                                                                                                                           in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure cs farInp farExp+                                                                                                                                                                        else+                                                                                                                                                                          let _ = "checkToken.fail"+                                                                                                                                                                           in let failExp =+                                                                                                                                                                                    Data.Set.Internal.Bin+                                                                                                                                                                                      1+                                                                                                                                                                                      ( Symantic.Parser.Grammar.Combinators.SomeFailure+                                                                                                                                                                                          ( case inputToken of+                                                                                                                                                                                              (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken 'i'+                                                                                                                                                                                          )+                                                                                                                                                                                      )+                                                                                                                                                                                      Data.Set.Internal.Tip+                                                                                                                                                                                      Data.Set.Internal.Tip+                                                                                                                                                                               in let (#+                                                                                                                                                                                        farInp,+                                                                                                                                                                                        farExp+                                                                                                                                                                                        #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp inp of+                                                                                                                                                                                          GHC.Types.LT ->+                                                                                                                                                                                            (#+                                                                                                                                                                                              inp,+                                                                                                                                                                                              failExp+                                                                                                                                                                                            #)+                                                                                                                                                                                          GHC.Types.EQ ->+                                                                                                                                                                                            (#+                                                                                                                                                                                              farInp,+                                                                                                                                                                                              failExp GHC.Base.<> farExp+                                                                                                                                                                                            #)+                                                                                                                                                                                          GHC.Types.GT ->+                                                                                                                                                                                            (#+                                                                                                                                                                                              farInp,+                                                                                                                                                                                              farExp+                                                                                                                                                                                            #)+                                                                                                                                                                                   in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp+                                                                                                                                                            else+                                                                                                                                                              let _ = "checkHorizon.newCheck.fail"+                                                                                                                                                               in let failExp =+                                                                                                                                                                        Data.Set.Internal.Bin+                                                                                                                                                                          1+                                                                                                                                                                          ( Symantic.Parser.Grammar.Combinators.SomeFailure+                                                                                                                                                                              ( case inputToken of+                                                                                                                                                                                  (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureHorizon @tok' 2+                                                                                                                                                                              )+                                                                                                                                                                          )+                                                                                                                                                                          Data.Set.Internal.Tip+                                                                                                                                                                          Data.Set.Internal.Tip+                                                                                                                                                                   in let (#+                                                                                                                                                                            farInp,+                                                                                                                                                                            farExp+                                                                                                                                                                            #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp inp of+                                                                                                                                                                              GHC.Types.LT ->+                                                                                                                                                                                (#+                                                                                                                                                                                  inp,+                                                                                                                                                                                  failExp+                                                                                                                                                                                #)+                                                                                                                                                                              GHC.Types.EQ ->+                                                                                                                                                                                (#+                                                                                                                                                                                  farInp,+                                                                                                                                                                                  failExp GHC.Base.<> farExp+                                                                                                                                                                                #)+                                                                                                                                                                              GHC.Types.GT ->+                                                                                                                                                                                (#+                                                                                                                                                                                  farInp,+                                                                                                                                                                                  farExp+                                                                                                                                                                                #)+                                                                                                                                                                       in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp+                                                                                                     in let _ = "jump"+                                                                                                         in loop callerOnReturn inp (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure readFail Data.Map.Internal.Tip Data.Map.Internal.Tip)+                                                                              )+                                                                              cs+                                                                              (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure readFail Data.Map.Internal.Tip Data.Map.Internal.Tip)+                                                                      else+                                                                        let _ = "checkToken.fail"+                                                                         in let failExp =+                                                                                  Data.Set.Internal.Bin+                                                                                    1+                                                                                    ( Symantic.Parser.Grammar.Combinators.SomeFailure+                                                                                        ( case inputToken of+                                                                                            (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken '{'+                                                                                        )+                                                                                    )+                                                                                    Data.Set.Internal.Tip+                                                                                    Data.Set.Internal.Tip+                                                                             in let (#+                                                                                      farInp,+                                                                                      farExp+                                                                                      #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init inp of+                                                                                        GHC.Types.LT ->+                                                                                          (#+                                                                                            inp,+                                                                                            failExp+                                                                                          #)+                                                                                        GHC.Types.EQ ->+                                                                                          (#+                                                                                            init,+                                                                                            failExp GHC.Base.<> Data.Set.Internal.empty+                                                                                          #)+                                                                                        GHC.Types.GT ->+                                                                                          (#+                                                                                            init,+                                                                                            Data.Set.Internal.empty+                                                                                          #)+                                                                                 in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp+                                                          else+                                                            let _ = "checkHorizon.newCheck.fail"+                                                             in let failExp =+                                                                      Data.Set.Internal.Bin+                                                                        1+                                                                        ( Symantic.Parser.Grammar.Combinators.SomeFailure+                                                                            ( case inputToken of+                                                                                (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureHorizon @tok' 4+                                                                            )+                                                                        )+                                                                        Data.Set.Internal.Tip+                                                                        Data.Set.Internal.Tip+                                                                 in let (#+                                                                          farInp,+                                                                          farExp+                                                                          #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init inp of+                                                                            GHC.Types.LT ->+                                                                              (#+                                                                                inp,+                                                                                failExp+                                                                              #)+                                                                            GHC.Types.EQ ->+                                                                              (#+                                                                                init,+                                                                                failExp GHC.Base.<> Data.Set.Internal.empty+                                                                              #)+                                                                            GHC.Types.GT ->+                                                                              (#+                                                                                init,+                                                                                Data.Set.Internal.empty+                                                                              #)+                                                                     in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp+                                  name = \(!callerOnReturn) (!callerInput) (!callerOnExceptionStackByLabel) ->+                                    let _ = "pushValue"+                                     in let _ = "comment: satisfy GHC.Unicode.isSpace"+                                         in let inp = callerInput+                                             in let readFail = Data.Map.Strict.Internal.findWithDefault finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure callerOnExceptionStackByLabel+                                                 in let _ = "checkHorizon.newCheck: checkedHorizon=0 minHoriz=1"+                                                     in if readMore inp+                                                          then+                                                            let _ = "checkToken"+                                                             in let !(#+                                                                       c,+                                                                       cs+                                                                       #) = readNext inp+                                                                 in if GHC.Unicode.isSpace c+                                                                      then+                                                                        let _ = "lift2Value checkedHorizon=1"+                                                                         in name+                                                                              ( let _ = "onReturn"+                                                                                 in \farInp farExp v (!inp) ->+                                                                                      let _ = "lift2Value checkedHorizon=0"+                                                                                       in let _ = "resume"+                                                                                           in callerOnReturn+                                                                                                farInp+                                                                                                farExp+                                                                                                ( let _ = "resume.genCode"+                                                                                                   in v+                                                                                                )+                                                                                                inp+                                                                              )+                                                                              cs+                                                                              Data.Map.Internal.Tip+                                                                      else+                                                                        let _ = "checkToken.fail"+                                                                         in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure inp init Data.Set.Internal.empty+                                                          else+                                                            let _ = "checkHorizon.newCheck.fail"+                                                             in let failExp =+                                                                      Data.Set.Internal.Bin+                                                                        1+                                                                        ( Symantic.Parser.Grammar.Combinators.SomeFailure+                                                                            ( case inputToken of+                                                                                (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureHorizon @tok' 1+                                                                            )+                                                                        )+                                                                        Data.Set.Internal.Tip+                                                                        Data.Set.Internal.Tip+                                                                 in let (#+                                                                          farInp,+                                                                          farExp+                                                                          #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init inp of+                                                                            GHC.Types.LT ->+                                                                              (#+                                                                                inp,+                                                                                failExp+                                                                              #)+                                                                            GHC.Types.EQ ->+                                                                              (#+                                                                                init,+                                                                                failExp GHC.Base.<> Data.Set.Internal.empty+                                                                              #)+                                                                            GHC.Types.GT ->+                                                                              (#+                                                                                init,+                                                                                Data.Set.Internal.empty+                                                                              #)+                                                                     in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp+                                  name = \(!callerOnReturn) (!callerInput) (!callerOnExceptionStackByLabel) ->+                                    let _ = "pushValue"+                                     in let _ = "resume"+                                         in callerOnReturn+                                              init+                                              Data.Set.Internal.empty+                                              ( let _ = "resume.genCode"+                                                 in GHC.Tuple . ()+                                              )+                                              callerInput+                                  name = \(!callerOnReturn) (!callerInput) (!callerOnExceptionStackByLabel) ->+                                    let _ = "pushValue"+                                     in let _ = "resume"+                                         in callerOnReturn+                                              init+                                              Data.Set.Internal.empty+                                              ( let _ = "resume.genCode"+                                                 in GHC.Tuple . ()+                                              )+                                              callerInput+                                  name = \(!callerOnReturn) (!callerInput) (!callerOnExceptionStackByLabel) ->+                                    let _ = "pushValue"+                                     in let _ = "resume"+                                         in callerOnReturn+                                              init+                                              Data.Set.Internal.empty+                                              ( let _ = "resume.genCode"+                                                 in \x -> \x -> x+                                              )+                                              callerInput+                               in let _ = "pushValue"+                                   in name+                                        ( let _ = "onReturn"+                                           in \farInp farExp v (!inp) ->+                                                let _ = "lift2Value checkedHorizon=0"+                                                 in let _ = "pushValue"+                                                     in do+                                                          let dupv = \x -> x+                                                          reg <- GHC.STRef.newSTRef dupv+                                                          let _ = "iter"+                                                           in let onException loopInput =+                                                                    let _ = "onException"+                                                                     in \(!_exn) (!failInp) (!farInp) (!farExp) ->+                                                                          let _ = "comment: raiseAgainIfConsumed"+                                                                           in let _ = "saveInput checkedHorizon=0"+                                                                               in let _ = "lift2Value checkedHorizon=0"+                                                                                   in if ( \( Data.Text.Internal.Text+                                                                                                _+                                                                                                i+                                                                                                _+                                                                                              )+                                                                                            ( Data.Text.Internal.Text+                                                                                                _+                                                                                                j+                                                                                                _+                                                                                              ) -> i GHC.Classes.== j+                                                                                         )+                                                                                        loopInput+                                                                                        failInp+                                                                                        then+                                                                                          let _ = "choicesBranch checkedHorizon=0"+                                                                                           in do+                                                                                                sr <- GHC.STRef.readSTRef reg+                                                                                                name+                                                                                                  ( let _ = "onReturn"+                                                                                                     in \farInp farExp v (!inp) ->+                                                                                                          let _ = "lift2Value checkedHorizon=0"+                                                                                                           in let _ = "lift2Value checkedHorizon=0"+                                                                                                               in name+                                                                                                                    ( let _ = "onReturn"+                                                                                                                       in \farInp farExp v (!inp) ->+                                                                                                                            let _ = "lift2Value checkedHorizon=0"+                                                                                                                             in let join = \farInp farExp v (!inp) ->+                                                                                                                                      let _ = "lift2Value checkedHorizon=0"+                                                                                                                                       in let _ = "resume"+                                                                                                                                           in finalRet+                                                                                                                                                farInp+                                                                                                                                                farExp+                                                                                                                                                ( let _ = "resume.genCode"+                                                                                                                                                   in GHC.Show.show v+                                                                                                                                                )+                                                                                                                                                inp+                                                                                                                                 in let _ = "catch ExceptionFailure checkedHorizon=0"+                                                                                                                                     in let onException =+                                                                                                                                              let _ = "onException"+                                                                                                                                               in \(!_exn) (!failInp) (!farInp) (!farExp) ->+                                                                                                                                                    let _ = "comment: raiseAgainIfConsumed"+                                                                                                                                                     in let _ = "saveInput checkedHorizon=0"+                                                                                                                                                         in let _ = "lift2Value checkedHorizon=0"+                                                                                                                                                             in if ( \( Data.Text.Internal.Text+                                                                                                                                                                          _+                                                                                                                                                                          i+                                                                                                                                                                          _+                                                                                                                                                                        )+                                                                                                                                                                      ( Data.Text.Internal.Text+                                                                                                                                                                          _+                                                                                                                                                                          j+                                                                                                                                                                          _+                                                                                                                                                                        ) -> i GHC.Classes.== j+                                                                                                                                                                   )+                                                                                                                                                                  inp+                                                                                                                                                                  failInp+                                                                                                                                                                  then+                                                                                                                                                                    let _ = "choicesBranch checkedHorizon=0"+                                                                                                                                                                     in let _ = "comment: eof.fail"+                                                                                                                                                                         in let failExp = Data.Set.Internal.Bin 1 (Symantic.Parser.Grammar.Combinators.SomeFailure Symantic.Parser.Grammar.Combinators.FailureEnd) Data.Set.Internal.Tip Data.Set.Internal.Tip+                                                                                                                                                                             in let (#+                                                                                                                                                                                      farInp,+                                                                                                                                                                                      farExp+                                                                                                                                                                                      #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp failInp of+                                                                                                                                                                                        GHC.Types.LT ->+                                                                                                                                                                                          (#+                                                                                                                                                                                            failInp,+                                                                                                                                                                                            failExp+                                                                                                                                                                                          #)+                                                                                                                                                                                        GHC.Types.EQ ->+                                                                                                                                                                                          (#+                                                                                                                                                                                            farInp,+                                                                                                                                                                                            failExp GHC.Base.<> farExp+                                                                                                                                                                                          #)+                                                                                                                                                                                        GHC.Types.GT ->+                                                                                                                                                                                          (#+                                                                                                                                                                                            farInp,+                                                                                                                                                                                            farExp+                                                                                                                                                                                          #)+                                                                                                                                                                                 in finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp farInp farExp+                                                                                                                                                                  else+                                                                                                                                                                    let _ = "choicesBranch.else"+                                                                                                                                                                     in finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp farInp farExp+                                                                                                                                         in let _ = "comment: negLook"+                                                                                                                                             in let _ = "catch ExceptionFailure checkedHorizon=0"+                                                                                                                                                 in let onException =+                                                                                                                                                          let _ = "onException"+                                                                                                                                                           in \(!_exn) (!failInp) (!farInp) (!farExp) ->+                                                                                                                                                                let _ = "comment: negLook.reset"+                                                                                                                                                                 in let _ = "loadInput checkedHorizon=0"+                                                                                                                                                                     in let _ = "checkHorizon.noCheck"+                                                                                                                                                                         in let _ = "pushValue"+                                                                                                                                                                             in let _ = "commit"+                                                                                                                                                                                 in let _ = "resume"+                                                                                                                                                                                     in join+                                                                                                                                                                                          farInp+                                                                                                                                                                                          farExp+                                                                                                                                                                                          ( let _ = "resume.genCode"+                                                                                                                                                                                             in GHC.Tuple . ()+                                                                                                                                                                                          )+                                                                                                                                                                                          inp+                                                                                                                                                     in let _ = "comment: negLook.ahead"+                                                                                                                                                         in let _ = "saveInput checkedHorizon=0"+                                                                                                                                                             in let _ = "comment: satisfy ((\\x_0 -> \\x_1 -> x_0) GHC.Types.True)"+                                                                                                                                                                 in let inp = inp+                                                                                                                                                                     in let readFail = onException+                                                                                                                                                                         in let _ = "checkHorizon.newCheck: checkedHorizon=0 minHoriz=1"+                                                                                                                                                                             in if readMore inp+                                                                                                                                                                                  then+                                                                                                                                                                                    let _ = "checkToken"+                                                                                                                                                                                     in let !(#+                                                                                                                                                                                               c,+                                                                                                                                                                                               cs+                                                                                                                                                                                               #) = readNext inp+                                                                                                                                                                                         in let _ = "popValue"+                                                                                                                                                                                             in let _ = "commit"+                                                                                                                                                                                                 in let _ = "loadInput checkedHorizon=0"+                                                                                                                                                                                                     in let _ = "checkHorizon.noCheck"+                                                                                                                                                                                                         in onException Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp+                                                                                                                                                                                  else+                                                                                                                                                                                    let _ = "checkHorizon.newCheck.fail"+                                                                                                                                                                                     in let failExp =+                                                                                                                                                                                              Data.Set.Internal.Bin+                                                                                                                                                                                                1+                                                                                                                                                                                                ( Symantic.Parser.Grammar.Combinators.SomeFailure+                                                                                                                                                                                                    ( case inputToken of+                                                                                                                                                                                                        (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureHorizon @tok' 1+                                                                                                                                                                                                    )+                                                                                                                                                                                                )+                                                                                                                                                                                                Data.Set.Internal.Tip+                                                                                                                                                                                                Data.Set.Internal.Tip+                                                                                                                                                                                         in let (#+                                                                                                                                                                                                  farInp,+                                                                                                                                                                                                  farExp+                                                                                                                                                                                                  #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp inp of+                                                                                                                                                                                                    GHC.Types.LT ->+                                                                                                                                                                                                      (#+                                                                                                                                                                                                        inp,+                                                                                                                                                                                                        failExp+                                                                                                                                                                                                      #)+                                                                                                                                                                                                    GHC.Types.EQ ->+                                                                                                                                                                                                      (#+                                                                                                                                                                                                        farInp,+                                                                                                                                                                                                        failExp GHC.Base.<> farExp+                                                                                                                                                                                                      #)+                                                                                                                                                                                                    GHC.Types.GT ->+                                                                                                                                                                                                      (#+                                                                                                                                                                                                        farInp,+                                                                                                                                                                                                        farExp+                                                                                                                                                                                                      #)+                                                                                                                                                                                             in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp+                                                                                                                    )+                                                                                                                    inp+                                                                                                                    Data.Map.Internal.Tip+                                                                                                  )+                                                                                                  failInp+                                                                                                  Data.Map.Internal.Tip+                                                                                        else+                                                                                          let _ = "choicesBranch.else"+                                                                                           in finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp farInp farExp+                                                                  loop = \_callerOnReturn callerInput callerOnExceptionStackByLabel ->+                                                                    let _ = "pushValue"+                                                                     in let _ = "catch ExceptionFailure checkedHorizon=0"+                                                                         in let onException =+                                                                                  let _ = "onException"+                                                                                   in \(!_exn) (!failInp) (!farInp) (!farExp) ->+                                                                                        let _ = "loadInput checkedHorizon=0"+                                                                                         in let _ = "checkHorizon.noCheck"+                                                                                             in onException callerInput Symantic.Parser.Grammar.Combinators.ExceptionFailure callerInput farInp farExp+                                                                             in let _ = "pushValue"+                                                                                 in let _ = "comment: satisfy ((GHC.Classes.==) 'f')"+                                                                                     in let inp = callerInput+                                                                                         in let readFail = onException+                                                                                             in let _ = "checkHorizon.newCheck: checkedHorizon=0 minHoriz=18"+                                                                                                 in if readMore (Symantic.Parser.Machine.Input.shiftRightText 17 inp)+                                                                                                      then+                                                                                                        let _ = "checkToken"+                                                                                                         in let !(#+                                                                                                                   c,+                                                                                                                   cs+                                                                                                                   #) = readNext inp+                                                                                                             in if (GHC.Classes.==) 'f' c+                                                                                                                  then+                                                                                                                    let _ = "lift2Value checkedHorizon=18"+                                                                                                                     in let _ = "comment: satisfy ((GHC.Classes.==) 'u')"+                                                                                                                         in let _ = "checkHorizon.oldCheck: checkedHorizon=18"+                                                                                                                             in let _ = "checkToken"+                                                                                                                                 in let !(#+                                                                                                                                           c,+                                                                                                                                           cs+                                                                                                                                           #) = readNext cs+                                                                                                                                     in if (GHC.Classes.==) 'u' c+                                                                                                                                          then+                                                                                                                                            let _ = "lift2Value checkedHorizon=17"+                                                                                                                                             in let _ = "comment: satisfy ((GHC.Classes.==) 'n')"+                                                                                                                                                 in let _ = "checkHorizon.oldCheck: checkedHorizon=17"+                                                                                                                                                     in let _ = "checkToken"+                                                                                                                                                         in let !(#+                                                                                                                                                                   c,+                                                                                                                                                                   cs+                                                                                                                                                                   #) = readNext cs+                                                                                                                                                             in if (GHC.Classes.==) 'n' c+                                                                                                                                                                  then+                                                                                                                                                                    let _ = "lift2Value checkedHorizon=16"+                                                                                                                                                                     in let _ = "comment: satisfy ((GHC.Classes.==) 'c')"+                                                                                                                                                                         in let _ = "checkHorizon.oldCheck: checkedHorizon=16"+                                                                                                                                                                             in let _ = "checkToken"+                                                                                                                                                                                 in let !(#+                                                                                                                                                                                           c,+                                                                                                                                                                                           cs+                                                                                                                                                                                           #) = readNext cs+                                                                                                                                                                                     in if (GHC.Classes.==) 'c' c+                                                                                                                                                                                          then+                                                                                                                                                                                            let _ = "lift2Value checkedHorizon=15"+                                                                                                                                                                                             in let _ = "comment: satisfy ((GHC.Classes.==) 't')"+                                                                                                                                                                                                 in let _ = "checkHorizon.oldCheck: checkedHorizon=15"+                                                                                                                                                                                                     in let _ = "checkToken"+                                                                                                                                                                                                         in let !(#+                                                                                                                                                                                                                   c,+                                                                                                                                                                                                                   cs+                                                                                                                                                                                                                   #) = readNext cs+                                                                                                                                                                                                             in if (GHC.Classes.==) 't' c+                                                                                                                                                                                                                  then+                                                                                                                                                                                                                    let _ = "lift2Value checkedHorizon=14"+                                                                                                                                                                                                                     in let _ = "comment: satisfy ((GHC.Classes.==) 'i')"+                                                                                                                                                                                                                         in let _ = "checkHorizon.oldCheck: checkedHorizon=14"+                                                                                                                                                                                                                             in let _ = "checkToken"+                                                                                                                                                                                                                                 in let !(#+                                                                                                                                                                                                                                           c,+                                                                                                                                                                                                                                           cs+                                                                                                                                                                                                                                           #) = readNext cs+                                                                                                                                                                                                                                     in if (GHC.Classes.==) 'i' c+                                                                                                                                                                                                                                          then+                                                                                                                                                                                                                                            let _ = "lift2Value checkedHorizon=13"+                                                                                                                                                                                                                                             in let _ = "comment: satisfy ((GHC.Classes.==) 'o')"+                                                                                                                                                                                                                                                 in let _ = "checkHorizon.oldCheck: checkedHorizon=13"+                                                                                                                                                                                                                                                     in let _ = "checkToken"+                                                                                                                                                                                                                                                         in let !(#+                                                                                                                                                                                                                                                                   c,+                                                                                                                                                                                                                                                                   cs+                                                                                                                                                                                                                                                                   #) = readNext cs+                                                                                                                                                                                                                                                             in if (GHC.Classes.==) 'o' c+                                                                                                                                                                                                                                                                  then+                                                                                                                                                                                                                                                                    let _ = "lift2Value checkedHorizon=12"+                                                                                                                                                                                                                                                                     in let _ = "comment: satisfy ((GHC.Classes.==) 'n')"+                                                                                                                                                                                                                                                                         in let _ = "checkHorizon.oldCheck: checkedHorizon=12"+                                                                                                                                                                                                                                                                             in let _ = "checkToken"+                                                                                                                                                                                                                                                                                 in let !(#+                                                                                                                                                                                                                                                                                           c,+                                                                                                                                                                                                                                                                                           cs+                                                                                                                                                                                                                                                                                           #) = readNext cs+                                                                                                                                                                                                                                                                                     in if (GHC.Classes.==) 'n' c+                                                                                                                                                                                                                                                                                          then+                                                                                                                                                                                                                                                                                            let _ = "lift2Value checkedHorizon=11"+                                                                                                                                                                                                                                                                                             in let _ = "commit"+                                                                                                                                                                                                                                                                                                 in let _ = "lift2Value checkedHorizon=11"+                                                                                                                                                                                                                                                                                                     in name+                                                                                                                                                                                                                                                                                                          ( let _ = "onReturn"+                                                                                                                                                                                                                                                                                                             in \farInp farExp v (!inp) ->+                                                                                                                                                                                                                                                                                                                  let _ = "lift2Value checkedHorizon=0"+                                                                                                                                                                                                                                                                                                                   in name+                                                                                                                                                                                                                                                                                                                        ( let _ = "onReturn"+                                                                                                                                                                                                                                                                                                                           in \farInp farExp v (!inp) ->+                                                                                                                                                                                                                                                                                                                                let _ = "lift2Value checkedHorizon=0"+                                                                                                                                                                                                                                                                                                                                 in name+                                                                                                                                                                                                                                                                                                                                      ( let _ = "onReturn"+                                                                                                                                                                                                                                                                                                                                         in \farInp farExp v (!inp) ->+                                                                                                                                                                                                                                                                                                                                              let _ = "lift2Value checkedHorizon=0"+                                                                                                                                                                                                                                                                                                                                               in name+                                                                                                                                                                                                                                                                                                                                                    ( let _ = "onReturn"+                                                                                                                                                                                                                                                                                                                                                       in \farInp farExp v (!inp) ->+                                                                                                                                                                                                                                                                                                                                                            let _ = "lift2Value checkedHorizon=0"+                                                                                                                                                                                                                                                                                                                                                             in let join = \farInp farExp v (!inp) ->+                                                                                                                                                                                                                                                                                                                                                                      let _ = "lift2Value checkedHorizon=0"+                                                                                                                                                                                                                                                                                                                                                                       in name+                                                                                                                                                                                                                                                                                                                                                                            ( let _ = "onReturn"+                                                                                                                                                                                                                                                                                                                                                                               in \farInp farExp v (!inp) ->+                                                                                                                                                                                                                                                                                                                                                                                    let _ = "lift2Value checkedHorizon=0"+                                                                                                                                                                                                                                                                                                                                                                                     in name+                                                                                                                                                                                                                                                                                                                                                                                          ( let _ = "onReturn"+                                                                                                                                                                                                                                                                                                                                                                                             in \farInp farExp v (!inp) ->+                                                                                                                                                                                                                                                                                                                                                                                                  let _ = "lift2Value checkedHorizon=0"+                                                                                                                                                                                                                                                                                                                                                                                                   in do+                                                                                                                                                                                                                                                                                                                                                                                                        sr <- GHC.STRef.readSTRef reg+                                                                                                                                                                                                                                                                                                                                                                                                        let _ = "lift2Value checkedHorizon=0"+                                                                                                                                                                                                                                                                                                                                                                                                         in do+                                                                                                                                                                                                                                                                                                                                                                                                              let dupv = sr+                                                                                                                                                                                                                                                                                                                                                                                                              GHC.STRef.writeSTRef reg dupv+                                                                                                                                                                                                                                                                                                                                                                                                              let _ = "jump"+                                                                                                                                                                                                                                                                                                                                                                                                               in loop (GHC.Err.error "invalid onReturn") inp (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure (onException callerInput) Data.Map.Internal.Tip Data.Map.Internal.Tip)+                                                                                                                                                                                                                                                                                                                                                                                          )+                                                                                                                                                                                                                                                                                                                                                                                          inp+                                                                                                                                                                                                                                                                                                                                                                                          (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure (onException callerInput) Data.Map.Internal.Tip Data.Map.Internal.Tip)+                                                                                                                                                                                                                                                                                                                                                                            )+                                                                                                                                                                                                                                                                                                                                                                            inp+                                                                                                                                                                                                                                                                                                                                                                            (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure (onException callerInput) Data.Map.Internal.Tip Data.Map.Internal.Tip)+                                                                                                                                                                                                                                                                                                                                                                 in let _ = "catch ExceptionFailure checkedHorizon=0"+                                                                                                                                                                                                                                                                                                                                                                     in let onException =+                                                                                                                                                                                                                                                                                                                                                                              let _ = "onException"+                                                                                                                                                                                                                                                                                                                                                                               in \(!_exn) (!failInp) (!farInp) (!farExp) ->+                                                                                                                                                                                                                                                                                                                                                                                    let _ = "comment: raiseAgainIfConsumed"+                                                                                                                                                                                                                                                                                                                                                                                     in let _ = "saveInput checkedHorizon=0"+                                                                                                                                                                                                                                                                                                                                                                                         in let _ = "lift2Value checkedHorizon=0"+                                                                                                                                                                                                                                                                                                                                                                                             in if ( \( Data.Text.Internal.Text+                                                                                                                                                                                                                                                                                                                                                                                                          _+                                                                                                                                                                                                                                                                                                                                                                                                          i+                                                                                                                                                                                                                                                                                                                                                                                                          _+                                                                                                                                                                                                                                                                                                                                                                                                        )+                                                                                                                                                                                                                                                                                                                                                                                                      ( Data.Text.Internal.Text+                                                                                                                                                                                                                                                                                                                                                                                                          _+                                                                                                                                                                                                                                                                                                                                                                                                          j+                                                                                                                                                                                                                                                                                                                                                                                                          _+                                                                                                                                                                                                                                                                                                                                                                                                        ) -> i GHC.Classes.== j+                                                                                                                                                                                                                                                                                                                                                                                                   )+                                                                                                                                                                                                                                                                                                                                                                                                  inp+                                                                                                                                                                                                                                                                                                                                                                                                  failInp+                                                                                                                                                                                                                                                                                                                                                                                                  then+                                                                                                                                                                                                                                                                                                                                                                                                    let _ = "choicesBranch checkedHorizon=0"+                                                                                                                                                                                                                                                                                                                                                                                                     in name+                                                                                                                                                                                                                                                                                                                                                                                                          ( let _ = "onReturn"+                                                                                                                                                                                                                                                                                                                                                                                                             in \farInp farExp v (!inp) ->+                                                                                                                                                                                                                                                                                                                                                                                                                  let _ = "resume"+                                                                                                                                                                                                                                                                                                                                                                                                                   in join+                                                                                                                                                                                                                                                                                                                                                                                                                        farInp+                                                                                                                                                                                                                                                                                                                                                                                                                        farExp+                                                                                                                                                                                                                                                                                                                                                                                                                        ( let _ = "resume.genCode"+                                                                                                                                                                                                                                                                                                                                                                                                                           in v+                                                                                                                                                                                                                                                                                                                                                                                                                        )+                                                                                                                                                                                                                                                                                                                                                                                                                        inp+                                                                                                                                                                                                                                                                                                                                                                                                          )+                                                                                                                                                                                                                                                                                                                                                                                                          failInp+                                                                                                                                                                                                                                                                                                                                                                                                          Data.Map.Internal.Tip+                                                                                                                                                                                                                                                                                                                                                                                                  else+                                                                                                                                                                                                                                                                                                                                                                                                    let _ = "choicesBranch.else"+                                                                                                                                                                                                                                                                                                                                                                                                     in onException callerInput Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp farInp farExp+                                                                                                                                                                                                                                                                                                                                                                         in let _ = "pushValue"+                                                                                                                                                                                                                                                                                                                                                                             in let _ = "comment: satisfy ((GHC.Classes.==) ':')"+                                                                                                                                                                                                                                                                                                                                                                                 in let inp = inp+                                                                                                                                                                                                                                                                                                                                                                                     in let readFail = onException+                                                                                                                                                                                                                                                                                                                                                                                         in let _ = "checkHorizon.newCheck: checkedHorizon=0 minHoriz=8"+                                                                                                                                                                                                                                                                                                                                                                                             in if readMore (Symantic.Parser.Machine.Input.shiftRightText 7 inp)+                                                                                                                                                                                                                                                                                                                                                                                                  then+                                                                                                                                                                                                                                                                                                                                                                                                    let _ = "checkToken"+                                                                                                                                                                                                                                                                                                                                                                                                     in let !(#+                                                                                                                                                                                                                                                                                                                                                                                                               c,+                                                                                                                                                                                                                                                                                                                                                                                                               cs+                                                                                                                                                                                                                                                                                                                                                                                                               #) = readNext inp+                                                                                                                                                                                                                                                                                                                                                                                                         in if (GHC.Classes.==) ':' c+                                                                                                                                                                                                                                                                                                                                                                                                              then+                                                                                                                                                                                                                                                                                                                                                                                                                let _ = "lift2Value checkedHorizon=8"+                                                                                                                                                                                                                                                                                                                                                                                                                 in name+                                                                                                                                                                                                                                                                                                                                                                                                                      ( let _ = "onReturn"+                                                                                                                                                                                                                                                                                                                                                                                                                         in \farInp farExp v (!inp) ->+                                                                                                                                                                                                                                                                                                                                                                                                                              let _ = "lift2Value checkedHorizon=0"+                                                                                                                                                                                                                                                                                                                                                                                                                               in name+                                                                                                                                                                                                                                                                                                                                                                                                                                    ( let _ = "onReturn"+                                                                                                                                                                                                                                                                                                                                                                                                                                       in \farInp farExp v (!inp) ->+                                                                                                                                                                                                                                                                                                                                                                                                                                            let _ = "lift2Value checkedHorizon=0"+                                                                                                                                                                                                                                                                                                                                                                                                                                             in let _ = "commit"+                                                                                                                                                                                                                                                                                                                                                                                                                                                 in let _ = "resume"+                                                                                                                                                                                                                                                                                                                                                                                                                                                     in join+                                                                                                                                                                                                                                                                                                                                                                                                                                                          farInp+                                                                                                                                                                                                                                                                                                                                                                                                                                                          farExp+                                                                                                                                                                                                                                                                                                                                                                                                                                                          ( let _ = "resume.genCode"+                                                                                                                                                                                                                                                                                                                                                                                                                                                             in GHC.Tuple . ()+                                                                                                                                                                                                                                                                                                                                                                                                                                                          )+                                                                                                                                                                                                                                                                                                                                                                                                                                                          inp+                                                                                                                                                                                                                                                                                                                                                                                                                                    )+                                                                                                                                                                                                                                                                                                                                                                                                                                    inp+                                                                                                                                                                                                                                                                                                                                                                                                                                    (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure readFail Data.Map.Internal.Tip Data.Map.Internal.Tip)+                                                                                                                                                                                                                                                                                                                                                                                                                      )+                                                                                                                                                                                                                                                                                                                                                                                                                      cs+                                                                                                                                                                                                                                                                                                                                                                                                                      (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure readFail Data.Map.Internal.Tip Data.Map.Internal.Tip)+                                                                                                                                                                                                                                                                                                                                                                                                              else+                                                                                                                                                                                                                                                                                                                                                                                                                let _ = "checkToken.fail"+                                                                                                                                                                                                                                                                                                                                                                                                                 in let failExp =+                                                                                                                                                                                                                                                                                                                                                                                                                          Data.Set.Internal.Bin+                                                                                                                                                                                                                                                                                                                                                                                                                            1+                                                                                                                                                                                                                                                                                                                                                                                                                            ( Symantic.Parser.Grammar.Combinators.SomeFailure+                                                                                                                                                                                                                                                                                                                                                                                                                                ( case inputToken of+                                                                                                                                                                                                                                                                                                                                                                                                                                    (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken ':'+                                                                                                                                                                                                                                                                                                                                                                                                                                )+                                                                                                                                                                                                                                                                                                                                                                                                                            )+                                                                                                                                                                                                                                                                                                                                                                                                                            Data.Set.Internal.Tip+                                                                                                                                                                                                                                                                                                                                                                                                                            Data.Set.Internal.Tip+                                                                                                                                                                                                                                                                                                                                                                                                                     in let (#+                                                                                                                                                                                                                                                                                                                                                                                                                              farInp,+                                                                                                                                                                                                                                                                                                                                                                                                                              farExp+                                                                                                                                                                                                                                                                                                                                                                                                                              #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp inp of+                                                                                                                                                                                                                                                                                                                                                                                                                                GHC.Types.LT ->+                                                                                                                                                                                                                                                                                                                                                                                                                                  (#+                                                                                                                                                                                                                                                                                                                                                                                                                                    inp,+                                                                                                                                                                                                                                                                                                                                                                                                                                    failExp+                                                                                                                                                                                                                                                                                                                                                                                                                                  #)+                                                                                                                                                                                                                                                                                                                                                                                                                                GHC.Types.EQ ->+                                                                                                                                                                                                                                                                                                                                                                                                                                  (#+                                                                                                                                                                                                                                                                                                                                                                                                                                    farInp,+                                                                                                                                                                                                                                                                                                                                                                                                                                    failExp GHC.Base.<> farExp+                                                                                                                                                                                                                                                                                                                                                                                                                                  #)+                                                                                                                                                                                                                                                                                                                                                                                                                                GHC.Types.GT ->+                                                                                                                                                                                                                                                                                                                                                                                                                                  (#+                                                                                                                                                                                                                                                                                                                                                                                                                                    farInp,+                                                                                                                                                                                                                                                                                                                                                                                                                                    farExp+                                                                                                                                                                                                                                                                                                                                                                                                                                  #)+                                                                                                                                                                                                                                                                                                                                                                                                                         in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp+                                                                                                                                                                                                                                                                                                                                                                                                  else+                                                                                                                                                                                                                                                                                                                                                                                                    let _ = "checkHorizon.newCheck.fail"+                                                                                                                                                                                                                                                                                                                                                                                                     in let failExp =+                                                                                                                                                                                                                                                                                                                                                                                                              Data.Set.Internal.Bin+                                                                                                                                                                                                                                                                                                                                                                                                                1+                                                                                                                                                                                                                                                                                                                                                                                                                ( Symantic.Parser.Grammar.Combinators.SomeFailure+                                                                                                                                                                                                                                                                                                                                                                                                                    ( case inputToken of+                                                                                                                                                                                                                                                                                                                                                                                                                        (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureHorizon @tok' 8+                                                                                                                                                                                                                                                                                                                                                                                                                    )+                                                                                                                                                                                                                                                                                                                                                                                                                )+                                                                                                                                                                                                                                                                                                                                                                                                                Data.Set.Internal.Tip+                                                                                                                                                                                                                                                                                                                                                                                                                Data.Set.Internal.Tip+                                                                                                                                                                                                                                                                                                                                                                                                         in let (#+                                                                                                                                                                                                                                                                                                                                                                                                                  farInp,+                                                                                                                                                                                                                                                                                                                                                                                                                  farExp+                                                                                                                                                                                                                                                                                                                                                                                                                  #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp inp of+                                                                                                                                                                                                                                                                                                                                                                                                                    GHC.Types.LT ->+                                                                                                                                                                                                                                                                                                                                                                                                                      (#+                                                                                                                                                                                                                                                                                                                                                                                                                        inp,+                                                                                                                                                                                                                                                                                                                                                                                                                        failExp+                                                                                                                                                                                                                                                                                                                                                                                                                      #)+                                                                                                                                                                                                                                                                                                                                                                                                                    GHC.Types.EQ ->+                                                                                                                                                                                                                                                                                                                                                                                                                      (#+                                                                                                                                                                                                                                                                                                                                                                                                                        farInp,+                                                                                                                                                                                                                                                                                                                                                                                                                        failExp GHC.Base.<> farExp+                                                                                                                                                                                                                                                                                                                                                                                                                      #)+                                                                                                                                                                                                                                                                                                                                                                                                                    GHC.Types.GT ->+                                                                                                                                                                                                                                                                                                                                                                                                                      (#+                                                                                                                                                                                                                                                                                                                                                                                                                        farInp,+                                                                                                                                                                                                                                                                                                                                                                                                                        farExp+                                                                                                                                                                                                                                                                                                                                                                                                                      #)+                                                                                                                                                                                                                                                                                                                                                                                                             in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp+                                                                                                                                                                                                                                                                                                                                                    )+                                                                                                                                                                                                                                                                                                                                                    inp+                                                                                                                                                                                                                                                                                                                                                    (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure (onException callerInput) Data.Map.Internal.Tip Data.Map.Internal.Tip)+                                                                                                                                                                                                                                                                                                                                      )+                                                                                                                                                                                                                                                                                                                                      inp+                                                                                                                                                                                                                                                                                                                                      (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure (onException callerInput) Data.Map.Internal.Tip Data.Map.Internal.Tip)+                                                                                                                                                                                                                                                                                                                        )+                                                                                                                                                                                                                                                                                                                        inp+                                                                                                                                                                                                                                                                                                                        (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure (onException callerInput) Data.Map.Internal.Tip Data.Map.Internal.Tip)+                                                                                                                                                                                                                                                                                                          )+                                                                                                                                                                                                                                                                                                          cs+                                                                                                                                                                                                                                                                                                          Data.Map.Internal.Tip+                                                                                                                                                                                                                                                                                          else+                                                                                                                                                                                                                                                                                            let _ = "checkToken.fail"+                                                                                                                                                                                                                                                                                             in let failExp =+                                                                                                                                                                                                                                                                                                      Data.Set.Internal.Bin+                                                                                                                                                                                                                                                                                                        1+                                                                                                                                                                                                                                                                                                        ( Symantic.Parser.Grammar.Combinators.SomeFailure+                                                                                                                                                                                                                                                                                                            ( case inputToken of+                                                                                                                                                                                                                                                                                                                (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken 'n'+                                                                                                                                                                                                                                                                                                            )+                                                                                                                                                                                                                                                                                                        )+                                                                                                                                                                                                                                                                                                        Data.Set.Internal.Tip+                                                                                                                                                                                                                                                                                                        Data.Set.Internal.Tip+                                                                                                                                                                                                                                                                                                 in let (#+                                                                                                                                                                                                                                                                                                          farInp,+                                                                                                                                                                                                                                                                                                          farExp+                                                                                                                                                                                                                                                                                                          #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp cs of+                                                                                                                                                                                                                                                                                                            GHC.Types.LT ->+                                                                                                                                                                                                                                                                                                              (#+                                                                                                                                                                                                                                                                                                                cs,+                                                                                                                                                                                                                                                                                                                failExp+                                                                                                                                                                                                                                                                                                              #)+                                                                                                                                                                                                                                                                                                            GHC.Types.EQ ->+                                                                                                                                                                                                                                                                                                              (#+                                                                                                                                                                                                                                                                                                                farInp,+                                                                                                                                                                                                                                                                                                                failExp GHC.Base.<> farExp+                                                                                                                                                                                                                                                                                                              #)+                                                                                                                                                                                                                                                                                                            GHC.Types.GT ->+                                                                                                                                                                                                                                                                                                              (#+                                                                                                                                                                                                                                                                                                                farInp,+                                                                                                                                                                                                                                                                                                                farExp+                                                                                                                                                                                                                                                                                                              #)+                                                                                                                                                                                                                                                                                                     in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure cs farInp farExp+                                                                                                                                                                                                                                                                  else+                                                                                                                                                                                                                                                                    let _ = "checkToken.fail"+                                                                                                                                                                                                                                                                     in let failExp =+                                                                                                                                                                                                                                                                              Data.Set.Internal.Bin+                                                                                                                                                                                                                                                                                1+                                                                                                                                                                                                                                                                                ( Symantic.Parser.Grammar.Combinators.SomeFailure+                                                                                                                                                                                                                                                                                    ( case inputToken of+                                                                                                                                                                                                                                                                                        (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken 'o'+                                                                                                                                                                                                                                                                                    )+                                                                                                                                                                                                                                                                                )+                                                                                                                                                                                                                                                                                Data.Set.Internal.Tip+                                                                                                                                                                                                                                                                                Data.Set.Internal.Tip+                                                                                                                                                                                                                                                                         in let (#+                                                                                                                                                                                                                                                                                  farInp,+                                                                                                                                                                                                                                                                                  farExp+                                                                                                                                                                                                                                                                                  #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp cs of+                                                                                                                                                                                                                                                                                    GHC.Types.LT ->+                                                                                                                                                                                                                                                                                      (#+                                                                                                                                                                                                                                                                                        cs,+                                                                                                                                                                                                                                                                                        failExp+                                                                                                                                                                                                                                                                                      #)+                                                                                                                                                                                                                                                                                    GHC.Types.EQ ->+                                                                                                                                                                                                                                                                                      (#+                                                                                                                                                                                                                                                                                        farInp,+                                                                                                                                                                                                                                                                                        failExp GHC.Base.<> farExp+                                                                                                                                                                                                                                                                                      #)+                                                                                                                                                                                                                                                                                    GHC.Types.GT ->+                                                                                                                                                                                                                                                                                      (#+                                                                                                                                                                                                                                                                                        farInp,+                                                                                                                                                                                                                                                                                        farExp+                                                                                                                                                                                                                                                                                      #)+                                                                                                                                                                                                                                                                             in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure cs farInp farExp+                                                                                                                                                                                                                                          else+                                                                                                                                                                                                                                            let _ = "checkToken.fail"+                                                                                                                                                                                                                                             in let failExp =+                                                                                                                                                                                                                                                      Data.Set.Internal.Bin+                                                                                                                                                                                                                                                        1+                                                                                                                                                                                                                                                        ( Symantic.Parser.Grammar.Combinators.SomeFailure+                                                                                                                                                                                                                                                            ( case inputToken of+                                                                                                                                                                                                                                                                (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken 'i'+                                                                                                                                                                                                                                                            )+                                                                                                                                                                                                                                                        )+                                                                                                                                                                                                                                                        Data.Set.Internal.Tip+                                                                                                                                                                                                                                                        Data.Set.Internal.Tip+                                                                                                                                                                                                                                                 in let (#+                                                                                                                                                                                                                                                          farInp,+                                                                                                                                                                                                                                                          farExp+                                                                                                                                                                                                                                                          #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp cs of+                                                                                                                                                                                                                                                            GHC.Types.LT ->+                                                                                                                                                                                                                                                              (#+                                                                                                                                                                                                                                                                cs,+                                                                                                                                                                                                                                                                failExp+                                                                                                                                                                                                                                                              #)+                                                                                                                                                                                                                                                            GHC.Types.EQ ->+                                                                                                                                                                                                                                                              (#+                                                                                                                                                                                                                                                                farInp,+                                                                                                                                                                                                                                                                failExp GHC.Base.<> farExp+                                                                                                                                                                                                                                                              #)+                                                                                                                                                                                                                                                            GHC.Types.GT ->+                                                                                                                                                                                                                                                              (#+                                                                                                                                                                                                                                                                farInp,+                                                                                                                                                                                                                                                                farExp+                                                                                                                                                                                                                                                              #)+                                                                                                                                                                                                                                                     in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure cs farInp farExp+                                                                                                                                                                                                                  else+                                                                                                                                                                                                                    let _ = "checkToken.fail"+                                                                                                                                                                                                                     in let failExp =+                                                                                                                                                                                                                              Data.Set.Internal.Bin+                                                                                                                                                                                                                                1+                                                                                                                                                                                                                                ( Symantic.Parser.Grammar.Combinators.SomeFailure+                                                                                                                                                                                                                                    ( case inputToken of+                                                                                                                                                                                                                                        (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken 't'+                                                                                                                                                                                                                                    )+                                                                                                                                                                                                                                )+                                                                                                                                                                                                                                Data.Set.Internal.Tip+                                                                                                                                                                                                                                Data.Set.Internal.Tip+                                                                                                                                                                                                                         in let (#+                                                                                                                                                                                                                                  farInp,+                                                                                                                                                                                                                                  farExp+                                                                                                                                                                                                                                  #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp cs of+                                                                                                                                                                                                                                    GHC.Types.LT ->+                                                                                                                                                                                                                                      (#+                                                                                                                                                                                                                                        cs,+                                                                                                                                                                                                                                        failExp+                                                                                                                                                                                                                                      #)+                                                                                                                                                                                                                                    GHC.Types.EQ ->+                                                                                                                                                                                                                                      (#+                                                                                                                                                                                                                                        farInp,+                                                                                                                                                                                                                                        failExp GHC.Base.<> farExp+                                                                                                                                                                                                                                      #)+                                                                                                                                                                                                                                    GHC.Types.GT ->+                                                                                                                                                                                                                                      (#+                                                                                                                                                                                                                                        farInp,+                                                                                                                                                                                                                                        farExp+                                                                                                                                                                                                                                      #)+                                                                                                                                                                                                                             in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure cs farInp farExp+                                                                                                                                                                                          else+                                                                                                                                                                                            let _ = "checkToken.fail"+                                                                                                                                                                                             in let failExp =+                                                                                                                                                                                                      Data.Set.Internal.Bin+                                                                                                                                                                                                        1+                                                                                                                                                                                                        ( Symantic.Parser.Grammar.Combinators.SomeFailure+                                                                                                                                                                                                            ( case inputToken of+                                                                                                                                                                                                                (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken 'c'+                                                                                                                                                                                                            )+                                                                                                                                                                                                        )+                                                                                                                                                                                                        Data.Set.Internal.Tip+                                                                                                                                                                                                        Data.Set.Internal.Tip+                                                                                                                                                                                                 in let (#+                                                                                                                                                                                                          farInp,+                                                                                                                                                                                                          farExp+                                                                                                                                                                                                          #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp cs of+                                                                                                                                                                                                            GHC.Types.LT ->+                                                                                                                                                                                                              (#+                                                                                                                                                                                                                cs,+                                                                                                                                                                                                                failExp+                                                                                                                                                                                                              #)+                                                                                                                                                                                                            GHC.Types.EQ ->+                                                                                                                                                                                                              (#+                                                                                                                                                                                                                farInp,+                                                                                                                                                                                                                failExp GHC.Base.<> farExp+                                                                                                                                                                                                              #)+                                                                                                                                                                                                            GHC.Types.GT ->+                                                                                                                                                                                                              (#+                                                                                                                                                                                                                farInp,+                                                                                                                                                                                                                farExp+                                                                                                                                                                                                              #)+                                                                                                                                                                                                     in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure cs farInp farExp+                                                                                                                                                                  else+                                                                                                                                                                    let _ = "checkToken.fail"+                                                                                                                                                                     in let failExp =+                                                                                                                                                                              Data.Set.Internal.Bin+                                                                                                                                                                                1+                                                                                                                                                                                ( Symantic.Parser.Grammar.Combinators.SomeFailure+                                                                                                                                                                                    ( case inputToken of+                                                                                                                                                                                        (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken 'n'+                                                                                                                                                                                    )+                                                                                                                                                                                )+                                                                                                                                                                                Data.Set.Internal.Tip+                                                                                                                                                                                Data.Set.Internal.Tip+                                                                                                                                                                         in let (#+                                                                                                                                                                                  farInp,+                                                                                                                                                                                  farExp+                                                                                                                                                                                  #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp cs of+                                                                                                                                                                                    GHC.Types.LT ->+                                                                                                                                                                                      (#+                                                                                                                                                                                        cs,+                                                                                                                                                                                        failExp+                                                                                                                                                                                      #)+                                                                                                                                                                                    GHC.Types.EQ ->+                                                                                                                                                                                      (#+                                                                                                                                                                                        farInp,+                                                                                                                                                                                        failExp GHC.Base.<> farExp+                                                                                                                                                                                      #)+                                                                                                                                                                                    GHC.Types.GT ->+                                                                                                                                                                                      (#+                                                                                                                                                                                        farInp,+                                                                                                                                                                                        farExp+                                                                                                                                                                                      #)+                                                                                                                                                                             in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure cs farInp farExp+                                                                                                                                          else+                                                                                                                                            let _ = "checkToken.fail"+                                                                                                                                             in let failExp =+                                                                                                                                                      Data.Set.Internal.Bin+                                                                                                                                                        1+                                                                                                                                                        ( Symantic.Parser.Grammar.Combinators.SomeFailure+                                                                                                                                                            ( case inputToken of+                                                                                                                                                                (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken 'u'+                                                                                                                                                            )+                                                                                                                                                        )+                                                                                                                                                        Data.Set.Internal.Tip+                                                                                                                                                        Data.Set.Internal.Tip+                                                                                                                                                 in let (#+                                                                                                                                                          farInp,+                                                                                                                                                          farExp+                                                                                                                                                          #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp cs of+                                                                                                                                                            GHC.Types.LT ->+                                                                                                                                                              (#+                                                                                                                                                                cs,+                                                                                                                                                                failExp+                                                                                                                                                              #)+                                                                                                                                                            GHC.Types.EQ ->+                                                                                                                                                              (#+                                                                                                                                                                farInp,+                                                                                                                                                                failExp GHC.Base.<> farExp+                                                                                                                                                              #)+                                                                                                                                                            GHC.Types.GT ->+                                                                                                                                                              (#+                                                                                                                                                                farInp,+                                                                                                                                                                farExp+                                                                                                                                                              #)+                                                                                                                                                     in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure cs farInp farExp+                                                                                                                  else+                                                                                                                    let _ = "checkToken.fail"+                                                                                                                     in let failExp =+                                                                                                                              Data.Set.Internal.Bin+                                                                                                                                1+                                                                                                                                ( Symantic.Parser.Grammar.Combinators.SomeFailure+                                                                                                                                    ( case inputToken of+                                                                                                                                        (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken 'f'+                                                                                                                                    )+                                                                                                                                )+                                                                                                                                Data.Set.Internal.Tip+                                                                                                                                Data.Set.Internal.Tip+                                                                                                                         in let (#+                                                                                                                                  farInp,+                                                                                                                                  farExp+                                                                                                                                  #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp inp of+                                                                                                                                    GHC.Types.LT ->+                                                                                                                                      (#+                                                                                                                                        inp,+                                                                                                                                        failExp+                                                                                                                                      #)+                                                                                                                                    GHC.Types.EQ ->+                                                                                                                                      (#+                                                                                                                                        farInp,+                                                                                                                                        failExp GHC.Base.<> farExp+                                                                                                                                      #)+                                                                                                                                    GHC.Types.GT ->+                                                                                                                                      (#+                                                                                                                                        farInp,+                                                                                                                                        farExp+                                                                                                                                      #)+                                                                                                                             in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp+                                                                                                      else+                                                                                                        let _ = "checkHorizon.newCheck.fail"+                                                                                                         in let failExp =+                                                                                                                  Data.Set.Internal.Bin+                                                                                                                    1+                                                                                                                    ( Symantic.Parser.Grammar.Combinators.SomeFailure+                                                                                                                        ( case inputToken of+                                                                                                                            (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureHorizon @tok' 18+                                                                                                                        )+                                                                                                                    )+                                                                                                                    Data.Set.Internal.Tip+                                                                                                                    Data.Set.Internal.Tip+                                                                                                             in let (#+                                                                                                                      farInp,+                                                                                                                      farExp+                                                                                                                      #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp inp of+                                                                                                                        GHC.Types.LT ->+                                                                                                                          (#+                                                                                                                            inp,+                                                                                                                            failExp+                                                                                                                          #)+                                                                                                                        GHC.Types.EQ ->+                                                                                                                          (#+                                                                                                                            farInp,+                                                                                                                            failExp GHC.Base.<> farExp+                                                                                                                          #)+                                                                                                                        GHC.Types.GT ->+                                                                                                                          (#+                                                                                                                            farInp,+                                                                                                                            farExp+                                                                                                                          #)+                                                                                                                 in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp+                                                               in let _ = "jump"+                                                                   in loop finalRet inp Data.Map.Internal.Tip+                                        )+                                        inp+                                        Data.Map.Internal.Tip+                            else+                              let _ = "checkHorizon.newCheck.fail"+                               in let failExp =+                                        Data.Set.Internal.Bin+                                          1+                                          ( Symantic.Parser.Grammar.Combinators.SomeFailure+                                              ( case inputToken of+                                                  (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureHorizon @tok' 1+                                              )+                                          )+                                          Data.Set.Internal.Tip+                                          Data.Set.Internal.Tip+                                   in let (#+                                            farInp,+                                            farExp+                                            #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init inp of+                                              GHC.Types.LT ->+                                                (#+                                                  inp,+                                                  failExp+                                                #)+                                              GHC.Types.EQ ->+                                                (#+                                                  init,+                                                  failExp GHC.Base.<> Data.Set.Internal.empty+                                                #)+                                              GHC.Types.GT ->+                                                (#+                                                  init,+                                                  Data.Set.Internal.empty+                                                #)+                                       in finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp+        )
+ tests/Golden/Splice/G15.expected.txt view
@@ -0,0 +1,379 @@+\(input :: inp) ->+  let !(#+         init,+         readMore,+         readNext+         #) =+          let _ = "cursorOf"+           in let next+                    ( t@( Data.Text.Internal.Text+                            arr+                            off+                            unconsumed+                          )+                      ) =+                      let !( Data.Text.Unsafe.Iter+                               c+                               d+                             ) = Data.Text.Unsafe.iter t 0+                       in (#+                            c,+                            Data.Text.Internal.Text arr (off GHC.Num.+ d) (unconsumed GHC.Num.- d)+                          #)+                  more+                    ( Data.Text.Internal.Text+                        _+                        _+                        unconsumed+                      ) = unconsumed GHC.Classes.> 0+               in (# input, more, next #)+      finalRet = \_farInp _farExp v _inp -> Symantic.Parser.Machine.Generate.returnST GHC.Base.$ Data.Either.Right v+      finalRaise ::+        forall st b.+        Symantic.Parser.Machine.Generate.OnException+          st+          inp+          b = \(!exn) _failInp (!farInp) (!farExp) ->+          Symantic.Parser.Machine.Generate.returnST GHC.Base.$+            Data.Either.Left+              Symantic.Parser.Machine.Generate.ParsingError+                { Symantic.Parser.Machine.Generate.parsingErrorOffset = Symantic.Parser.Machine.Input.offset farInp,+                  Symantic.Parser.Machine.Generate.parsingErrorException = exn,+                  Symantic.Parser.Machine.Generate.parsingErrorUnexpected =+                    if readMore farInp+                      then+                        GHC.Maybe.Just+                          ( let (#+                                  c,+                                  _+                                  #) = readNext farInp+                             in c+                          )+                      else GHC.Maybe.Nothing,+                  Symantic.Parser.Machine.Generate.parsingErrorExpecting =+                    let ( minHoriz,+                          res+                          ) =+                            Data.Set.Internal.foldr+                              ( \f+                                 ( minH,+                                   acc+                                   ) -> case Symantic.Parser.Grammar.Combinators.unSomeFailure f of+                                    GHC.Maybe.Just (Symantic.Parser.Grammar.Combinators.FailureHorizon h :: Symantic.Parser.Grammar.Combinators.Failure (Symantic.Parser.Grammar.Combinators.CombSatisfiable (Symantic.Parser.Machine.Input.InputToken inp)))+                                      | GHC.Maybe.Just old <- minH ->+                                        ( GHC.Maybe.Just (GHC.Classes.min old h),+                                          acc+                                        )+                                      | GHC.Base.otherwise ->+                                        ( GHC.Maybe.Just h,+                                          acc+                                        )+                                    _ ->+                                      ( minH,+                                        f GHC.Types.: acc+                                      )+                              )+                              ( GHC.Maybe.Nothing,+                                GHC.Types . []+                              )+                              farExp+                     in Data.Set.Internal.fromList GHC.Base.$+                          ( case minHoriz of+                              GHC.Maybe.Just h -> Symantic.Parser.Grammar.Combinators.SomeFailure (Symantic.Parser.Grammar.Combinators.FailureHorizon @(Symantic.Parser.Machine.Input.InputToken inp) h) GHC.Types.: res+                              GHC.Maybe.Nothing -> res+                          )+                }+   in GHC.ST.runST+        ( let inputToken = Data.Proxy.Proxy :: Data.Proxy.Proxy (Symantic.Parser.Machine.Input.InputToken inp)+           in let inp = init+               in let readFail = finalRaise+                   in let _ = "checkHorizon.newCheck: checkedHorizon=0 minHoriz=2"+                       in if readMore (Symantic.Parser.Machine.Input.shiftRightText 1 inp)+                            then+                              let+                               in let _ = "pushValue"+                                   in let join = \farInp farExp v (!inp) ->+                                            let _ = "lift2Value checkedHorizon=0"+                                             in let _ = "comment: satisfy ((GHC.Classes.==) 'c')"+                                                 in let inp = inp+                                                     in let readFail = finalRaise+                                                         in let _ = "checkHorizon.newCheck: checkedHorizon=0 minHoriz=1"+                                                             in if readMore inp+                                                                  then+                                                                    let _ = "checkToken"+                                                                     in let !(#+                                                                               c,+                                                                               cs+                                                                               #) = readNext inp+                                                                         in if (GHC.Classes.==) 'c' c+                                                                              then+                                                                                let _ = "lift2Value checkedHorizon=1"+                                                                                 in let _ = "resume"+                                                                                     in finalRet+                                                                                          farInp+                                                                                          farExp+                                                                                          ( let _ = "resume.genCode"+                                                                                             in GHC.Show.show v+                                                                                          )+                                                                                          cs+                                                                              else+                                                                                let _ = "checkToken.fail"+                                                                                 in let failExp =+                                                                                          Data.Set.Internal.Bin+                                                                                            1+                                                                                            ( Symantic.Parser.Grammar.Combinators.SomeFailure+                                                                                                ( case inputToken of+                                                                                                    (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken 'c'+                                                                                                )+                                                                                            )+                                                                                            Data.Set.Internal.Tip+                                                                                            Data.Set.Internal.Tip+                                                                                     in let (#+                                                                                              farInp,+                                                                                              farExp+                                                                                              #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp inp of+                                                                                                GHC.Types.LT ->+                                                                                                  (#+                                                                                                    inp,+                                                                                                    failExp+                                                                                                  #)+                                                                                                GHC.Types.EQ ->+                                                                                                  (#+                                                                                                    farInp,+                                                                                                    failExp GHC.Base.<> farExp+                                                                                                  #)+                                                                                                GHC.Types.GT ->+                                                                                                  (#+                                                                                                    farInp,+                                                                                                    farExp+                                                                                                  #)+                                                                                         in finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp+                                                                  else+                                                                    let _ = "checkHorizon.newCheck.fail"+                                                                     in let failExp =+                                                                              Data.Set.Internal.Bin+                                                                                1+                                                                                ( Symantic.Parser.Grammar.Combinators.SomeFailure+                                                                                    ( case inputToken of+                                                                                        (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureHorizon @tok' 1+                                                                                    )+                                                                                )+                                                                                Data.Set.Internal.Tip+                                                                                Data.Set.Internal.Tip+                                                                         in let (#+                                                                                  farInp,+                                                                                  farExp+                                                                                  #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp inp of+                                                                                    GHC.Types.LT ->+                                                                                      (#+                                                                                        inp,+                                                                                        failExp+                                                                                      #)+                                                                                    GHC.Types.EQ ->+                                                                                      (#+                                                                                        farInp,+                                                                                        failExp GHC.Base.<> farExp+                                                                                      #)+                                                                                    GHC.Types.GT ->+                                                                                      (#+                                                                                        farInp,+                                                                                        farExp+                                                                                      #)+                                                                             in finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp+                                       in let _ = "catch ExceptionFailure checkedHorizon=2"+                                           in let onException =+                                                    let _ = "onException"+                                                     in \(!_exn) (!failInp) (!farInp) (!farExp) ->+                                                          let _ = "comment: raiseAgainIfConsumed"+                                                           in let _ = "saveInput checkedHorizon=0"+                                                               in let _ = "lift2Value checkedHorizon=0"+                                                                   in if ( \( Data.Text.Internal.Text+                                                                                _+                                                                                i+                                                                                _+                                                                              )+                                                                            ( Data.Text.Internal.Text+                                                                                _+                                                                                j+                                                                                _+                                                                              ) -> i GHC.Classes.== j+                                                                         )+                                                                        inp+                                                                        failInp+                                                                        then+                                                                          let _ = "choicesBranch checkedHorizon=0"+                                                                           in let _ = "pushValue"+                                                                               in let _ = "comment: satisfy ((GHC.Classes.==) 'b')"+                                                                                   in let inp = failInp+                                                                                       in let readFail = finalRaise+                                                                                           in let _ = "checkHorizon.newCheck: checkedHorizon=0 minHoriz=2"+                                                                                               in if readMore (Symantic.Parser.Machine.Input.shiftRightText 1 inp)+                                                                                                    then+                                                                                                      let _ = "checkToken"+                                                                                                       in let !(#+                                                                                                                 c,+                                                                                                                 cs+                                                                                                                 #) = readNext inp+                                                                                                           in if (GHC.Classes.==) 'b' c+                                                                                                                then+                                                                                                                  let _ = "lift2Value checkedHorizon=2"+                                                                                                                   in let _ = "resume"+                                                                                                                       in join+                                                                                                                            farInp+                                                                                                                            farExp+                                                                                                                            ( let _ = "resume.genCode"+                                                                                                                               in 'b'+                                                                                                                            )+                                                                                                                            cs+                                                                                                                else+                                                                                                                  let _ = "checkToken.fail"+                                                                                                                   in let failExp =+                                                                                                                            Data.Set.Internal.Bin+                                                                                                                              1+                                                                                                                              ( Symantic.Parser.Grammar.Combinators.SomeFailure+                                                                                                                                  ( case inputToken of+                                                                                                                                      (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken 'b'+                                                                                                                                  )+                                                                                                                              )+                                                                                                                              Data.Set.Internal.Tip+                                                                                                                              Data.Set.Internal.Tip+                                                                                                                       in let (#+                                                                                                                                farInp,+                                                                                                                                farExp+                                                                                                                                #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp inp of+                                                                                                                                  GHC.Types.LT ->+                                                                                                                                    (#+                                                                                                                                      inp,+                                                                                                                                      failExp+                                                                                                                                    #)+                                                                                                                                  GHC.Types.EQ ->+                                                                                                                                    (#+                                                                                                                                      farInp,+                                                                                                                                      failExp GHC.Base.<> farExp+                                                                                                                                    #)+                                                                                                                                  GHC.Types.GT ->+                                                                                                                                    (#+                                                                                                                                      farInp,+                                                                                                                                      farExp+                                                                                                                                    #)+                                                                                                                           in finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp+                                                                                                    else+                                                                                                      let _ = "checkHorizon.newCheck.fail"+                                                                                                       in let failExp =+                                                                                                                Data.Set.Internal.Bin+                                                                                                                  1+                                                                                                                  ( Symantic.Parser.Grammar.Combinators.SomeFailure+                                                                                                                      ( case inputToken of+                                                                                                                          (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureHorizon @tok' 2+                                                                                                                      )+                                                                                                                  )+                                                                                                                  Data.Set.Internal.Tip+                                                                                                                  Data.Set.Internal.Tip+                                                                                                           in let (#+                                                                                                                    farInp,+                                                                                                                    farExp+                                                                                                                    #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp inp of+                                                                                                                      GHC.Types.LT ->+                                                                                                                        (#+                                                                                                                          inp,+                                                                                                                          failExp+                                                                                                                        #)+                                                                                                                      GHC.Types.EQ ->+                                                                                                                        (#+                                                                                                                          farInp,+                                                                                                                          failExp GHC.Base.<> farExp+                                                                                                                        #)+                                                                                                                      GHC.Types.GT ->+                                                                                                                        (#+                                                                                                                          farInp,+                                                                                                                          farExp+                                                                                                                        #)+                                                                                                               in finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp+                                                                        else+                                                                          let _ = "choicesBranch.else"+                                                                           in finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp farInp farExp+                                               in let _ = "pushValue"+                                                   in let _ = "comment: satisfy ((GHC.Classes.==) 'a')"+                                                       in let _ = "checkHorizon.oldCheck: checkedHorizon=2"+                                                           in let _ = "checkToken"+                                                               in let !(#+                                                                         c,+                                                                         cs+                                                                         #) = readNext inp+                                                                   in if (GHC.Classes.==) 'a' c+                                                                        then+                                                                          let _ = "lift2Value checkedHorizon=1"+                                                                           in let _ = "commit"+                                                                               in let _ = "resume"+                                                                                   in join+                                                                                        init+                                                                                        Data.Set.Internal.empty+                                                                                        ( let _ = "resume.genCode"+                                                                                           in 'a'+                                                                                        )+                                                                                        cs+                                                                        else+                                                                          let _ = "checkToken.fail"+                                                                           in let failExp =+                                                                                    Data.Set.Internal.Bin+                                                                                      1+                                                                                      ( Symantic.Parser.Grammar.Combinators.SomeFailure+                                                                                          ( case inputToken of+                                                                                              (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken 'a'+                                                                                          )+                                                                                      )+                                                                                      Data.Set.Internal.Tip+                                                                                      Data.Set.Internal.Tip+                                                                               in let (#+                                                                                        farInp,+                                                                                        farExp+                                                                                        #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init inp of+                                                                                          GHC.Types.LT ->+                                                                                            (#+                                                                                              inp,+                                                                                              failExp+                                                                                            #)+                                                                                          GHC.Types.EQ ->+                                                                                            (#+                                                                                              init,+                                                                                              failExp GHC.Base.<> Data.Set.Internal.empty+                                                                                            #)+                                                                                          GHC.Types.GT ->+                                                                                            (#+                                                                                              init,+                                                                                              Data.Set.Internal.empty+                                                                                            #)+                                                                                   in onException Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp+                            else+                              let _ = "checkHorizon.newCheck.fail"+                               in let failExp =+                                        Data.Set.Internal.Bin+                                          1+                                          ( Symantic.Parser.Grammar.Combinators.SomeFailure+                                              ( case inputToken of+                                                  (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureHorizon @tok' 2+                                              )+                                          )+                                          Data.Set.Internal.Tip+                                          Data.Set.Internal.Tip+                                   in let (#+                                            farInp,+                                            farExp+                                            #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init inp of+                                              GHC.Types.LT ->+                                                (#+                                                  inp,+                                                  failExp+                                                #)+                                              GHC.Types.EQ ->+                                                (#+                                                  init,+                                                  failExp GHC.Base.<> Data.Set.Internal.empty+                                                #)+                                              GHC.Types.GT ->+                                                (#+                                                  init,+                                                  Data.Set.Internal.empty+                                                #)+                                       in finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp+        )
+ tests/Golden/Splice/G16.expected.txt view
@@ -0,0 +1,492 @@+\(input :: inp) ->+  let !(#+         init,+         readMore,+         readNext+         #) =+          let _ = "cursorOf"+           in let next+                    ( t@( Data.Text.Internal.Text+                            arr+                            off+                            unconsumed+                          )+                      ) =+                      let !( Data.Text.Unsafe.Iter+                               c+                               d+                             ) = Data.Text.Unsafe.iter t 0+                       in (#+                            c,+                            Data.Text.Internal.Text arr (off GHC.Num.+ d) (unconsumed GHC.Num.- d)+                          #)+                  more+                    ( Data.Text.Internal.Text+                        _+                        _+                        unconsumed+                      ) = unconsumed GHC.Classes.> 0+               in (# input, more, next #)+      finalRet = \_farInp _farExp v _inp -> Symantic.Parser.Machine.Generate.returnST GHC.Base.$ Data.Either.Right v+      finalRaise ::+        forall st b.+        Symantic.Parser.Machine.Generate.OnException+          st+          inp+          b = \(!exn) _failInp (!farInp) (!farExp) ->+          Symantic.Parser.Machine.Generate.returnST GHC.Base.$+            Data.Either.Left+              Symantic.Parser.Machine.Generate.ParsingError+                { Symantic.Parser.Machine.Generate.parsingErrorOffset = Symantic.Parser.Machine.Input.offset farInp,+                  Symantic.Parser.Machine.Generate.parsingErrorException = exn,+                  Symantic.Parser.Machine.Generate.parsingErrorUnexpected =+                    if readMore farInp+                      then+                        GHC.Maybe.Just+                          ( let (#+                                  c,+                                  _+                                  #) = readNext farInp+                             in c+                          )+                      else GHC.Maybe.Nothing,+                  Symantic.Parser.Machine.Generate.parsingErrorExpecting =+                    let ( minHoriz,+                          res+                          ) =+                            Data.Set.Internal.foldr+                              ( \f+                                 ( minH,+                                   acc+                                   ) -> case Symantic.Parser.Grammar.Combinators.unSomeFailure f of+                                    GHC.Maybe.Just (Symantic.Parser.Grammar.Combinators.FailureHorizon h :: Symantic.Parser.Grammar.Combinators.Failure (Symantic.Parser.Grammar.Combinators.CombSatisfiable (Symantic.Parser.Machine.Input.InputToken inp)))+                                      | GHC.Maybe.Just old <- minH ->+                                        ( GHC.Maybe.Just (GHC.Classes.min old h),+                                          acc+                                        )+                                      | GHC.Base.otherwise ->+                                        ( GHC.Maybe.Just h,+                                          acc+                                        )+                                    _ ->+                                      ( minH,+                                        f GHC.Types.: acc+                                      )+                              )+                              ( GHC.Maybe.Nothing,+                                GHC.Types . []+                              )+                              farExp+                     in Data.Set.Internal.fromList GHC.Base.$+                          ( case minHoriz of+                              GHC.Maybe.Just h -> Symantic.Parser.Grammar.Combinators.SomeFailure (Symantic.Parser.Grammar.Combinators.FailureHorizon @(Symantic.Parser.Machine.Input.InputToken inp) h) GHC.Types.: res+                              GHC.Maybe.Nothing -> res+                          )+                }+   in GHC.ST.runST+        ( let inputToken = Data.Proxy.Proxy :: Data.Proxy.Proxy (Symantic.Parser.Machine.Input.InputToken inp)+           in let inp = init+               in let readFail = finalRaise+                   in let _ = "checkHorizon.newCheck: checkedHorizon=0 minHoriz=2"+                       in if readMore (Symantic.Parser.Machine.Input.shiftRightText 1 inp)+                            then+                              let+                               in let _ = "pushValue"+                                   in let join = \farInp farExp v (!inp) ->+                                            let _ = "lift2Value checkedHorizon=0"+                                             in let _ = "comment: satisfy ((GHC.Classes.==) 'd')"+                                                 in let inp = inp+                                                     in let readFail = finalRaise+                                                         in let _ = "checkHorizon.newCheck: checkedHorizon=0 minHoriz=1"+                                                             in if readMore inp+                                                                  then+                                                                    let _ = "checkToken"+                                                                     in let !(#+                                                                               c,+                                                                               cs+                                                                               #) = readNext inp+                                                                         in if (GHC.Classes.==) 'd' c+                                                                              then+                                                                                let _ = "lift2Value checkedHorizon=1"+                                                                                 in let _ = "resume"+                                                                                     in finalRet+                                                                                          farInp+                                                                                          farExp+                                                                                          ( let _ = "resume.genCode"+                                                                                             in GHC.Show.show v+                                                                                          )+                                                                                          cs+                                                                              else+                                                                                let _ = "checkToken.fail"+                                                                                 in let failExp =+                                                                                          Data.Set.Internal.Bin+                                                                                            1+                                                                                            ( Symantic.Parser.Grammar.Combinators.SomeFailure+                                                                                                ( case inputToken of+                                                                                                    (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken 'd'+                                                                                                )+                                                                                            )+                                                                                            Data.Set.Internal.Tip+                                                                                            Data.Set.Internal.Tip+                                                                                     in let (#+                                                                                              farInp,+                                                                                              farExp+                                                                                              #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp inp of+                                                                                                GHC.Types.LT ->+                                                                                                  (#+                                                                                                    inp,+                                                                                                    failExp+                                                                                                  #)+                                                                                                GHC.Types.EQ ->+                                                                                                  (#+                                                                                                    farInp,+                                                                                                    failExp GHC.Base.<> farExp+                                                                                                  #)+                                                                                                GHC.Types.GT ->+                                                                                                  (#+                                                                                                    farInp,+                                                                                                    farExp+                                                                                                  #)+                                                                                         in finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp+                                                                  else+                                                                    let _ = "checkHorizon.newCheck.fail"+                                                                     in let failExp =+                                                                              Data.Set.Internal.Bin+                                                                                1+                                                                                ( Symantic.Parser.Grammar.Combinators.SomeFailure+                                                                                    ( case inputToken of+                                                                                        (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureHorizon @tok' 1+                                                                                    )+                                                                                )+                                                                                Data.Set.Internal.Tip+                                                                                Data.Set.Internal.Tip+                                                                         in let (#+                                                                                  farInp,+                                                                                  farExp+                                                                                  #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp inp of+                                                                                    GHC.Types.LT ->+                                                                                      (#+                                                                                        inp,+                                                                                        failExp+                                                                                      #)+                                                                                    GHC.Types.EQ ->+                                                                                      (#+                                                                                        farInp,+                                                                                        failExp GHC.Base.<> farExp+                                                                                      #)+                                                                                    GHC.Types.GT ->+                                                                                      (#+                                                                                        farInp,+                                                                                        farExp+                                                                                      #)+                                                                             in finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp+                                       in let _ = "catch ExceptionFailure checkedHorizon=2"+                                           in let onException =+                                                    let _ = "onException"+                                                     in \(!_exn) (!failInp) (!farInp) (!farExp) ->+                                                          let _ = "comment: raiseAgainIfConsumed"+                                                           in let _ = "saveInput checkedHorizon=0"+                                                               in let _ = "lift2Value checkedHorizon=0"+                                                                   in if ( \( Data.Text.Internal.Text+                                                                                _+                                                                                i+                                                                                _+                                                                              )+                                                                            ( Data.Text.Internal.Text+                                                                                _+                                                                                j+                                                                                _+                                                                              ) -> i GHC.Classes.== j+                                                                         )+                                                                        inp+                                                                        failInp+                                                                        then+                                                                          let _ = "choicesBranch checkedHorizon=0"+                                                                           in let _ = "catch ExceptionFailure checkedHorizon=0"+                                                                               in let onException =+                                                                                        let _ = "onException"+                                                                                         in \(!_exn) (!failInp) (!farInp) (!farExp) ->+                                                                                              let _ = "comment: raiseAgainIfConsumed"+                                                                                               in let _ = "saveInput checkedHorizon=0"+                                                                                                   in let _ = "lift2Value checkedHorizon=0"+                                                                                                       in if ( \( Data.Text.Internal.Text+                                                                                                                    _+                                                                                                                    i+                                                                                                                    _+                                                                                                                  )+                                                                                                                ( Data.Text.Internal.Text+                                                                                                                    _+                                                                                                                    j+                                                                                                                    _+                                                                                                                  ) -> i GHC.Classes.== j+                                                                                                             )+                                                                                                            failInp+                                                                                                            failInp+                                                                                                            then+                                                                                                              let _ = "choicesBranch checkedHorizon=0"+                                                                                                               in let _ = "pushValue"+                                                                                                                   in let _ = "comment: satisfy ((GHC.Classes.==) 'c')"+                                                                                                                       in let inp = failInp+                                                                                                                           in let readFail = finalRaise+                                                                                                                               in let _ = "checkHorizon.newCheck: checkedHorizon=0 minHoriz=2"+                                                                                                                                   in if readMore (Symantic.Parser.Machine.Input.shiftRightText 1 inp)+                                                                                                                                        then+                                                                                                                                          let _ = "checkToken"+                                                                                                                                           in let !(#+                                                                                                                                                     c,+                                                                                                                                                     cs+                                                                                                                                                     #) = readNext inp+                                                                                                                                               in if (GHC.Classes.==) 'c' c+                                                                                                                                                    then+                                                                                                                                                      let _ = "lift2Value checkedHorizon=2"+                                                                                                                                                       in let _ = "resume"+                                                                                                                                                           in join+                                                                                                                                                                farInp+                                                                                                                                                                farExp+                                                                                                                                                                ( let _ = "resume.genCode"+                                                                                                                                                                   in 'c'+                                                                                                                                                                )+                                                                                                                                                                cs+                                                                                                                                                    else+                                                                                                                                                      let _ = "checkToken.fail"+                                                                                                                                                       in let failExp =+                                                                                                                                                                Data.Set.Internal.Bin+                                                                                                                                                                  1+                                                                                                                                                                  ( Symantic.Parser.Grammar.Combinators.SomeFailure+                                                                                                                                                                      ( case inputToken of+                                                                                                                                                                          (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken 'c'+                                                                                                                                                                      )+                                                                                                                                                                  )+                                                                                                                                                                  Data.Set.Internal.Tip+                                                                                                                                                                  Data.Set.Internal.Tip+                                                                                                                                                           in let (#+                                                                                                                                                                    farInp,+                                                                                                                                                                    farExp+                                                                                                                                                                    #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp inp of+                                                                                                                                                                      GHC.Types.LT ->+                                                                                                                                                                        (#+                                                                                                                                                                          inp,+                                                                                                                                                                          failExp+                                                                                                                                                                        #)+                                                                                                                                                                      GHC.Types.EQ ->+                                                                                                                                                                        (#+                                                                                                                                                                          farInp,+                                                                                                                                                                          failExp GHC.Base.<> farExp+                                                                                                                                                                        #)+                                                                                                                                                                      GHC.Types.GT ->+                                                                                                                                                                        (#+                                                                                                                                                                          farInp,+                                                                                                                                                                          farExp+                                                                                                                                                                        #)+                                                                                                                                                               in finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp+                                                                                                                                        else+                                                                                                                                          let _ = "checkHorizon.newCheck.fail"+                                                                                                                                           in let failExp =+                                                                                                                                                    Data.Set.Internal.Bin+                                                                                                                                                      1+                                                                                                                                                      ( Symantic.Parser.Grammar.Combinators.SomeFailure+                                                                                                                                                          ( case inputToken of+                                                                                                                                                              (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureHorizon @tok' 2+                                                                                                                                                          )+                                                                                                                                                      )+                                                                                                                                                      Data.Set.Internal.Tip+                                                                                                                                                      Data.Set.Internal.Tip+                                                                                                                                               in let (#+                                                                                                                                                        farInp,+                                                                                                                                                        farExp+                                                                                                                                                        #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp inp of+                                                                                                                                                          GHC.Types.LT ->+                                                                                                                                                            (#+                                                                                                                                                              inp,+                                                                                                                                                              failExp+                                                                                                                                                            #)+                                                                                                                                                          GHC.Types.EQ ->+                                                                                                                                                            (#+                                                                                                                                                              farInp,+                                                                                                                                                              failExp GHC.Base.<> farExp+                                                                                                                                                            #)+                                                                                                                                                          GHC.Types.GT ->+                                                                                                                                                            (#+                                                                                                                                                              farInp,+                                                                                                                                                              farExp+                                                                                                                                                            #)+                                                                                                                                                   in finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp+                                                                                                            else+                                                                                                              let _ = "choicesBranch.else"+                                                                                                               in finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp farInp farExp+                                                                                   in let _ = "pushValue"+                                                                                       in let _ = "comment: satisfy ((GHC.Classes.==) 'b')"+                                                                                           in let inp = failInp+                                                                                               in let readFail = onException+                                                                                                   in let _ = "checkHorizon.newCheck: checkedHorizon=0 minHoriz=2"+                                                                                                       in if readMore (Symantic.Parser.Machine.Input.shiftRightText 1 inp)+                                                                                                            then+                                                                                                              let _ = "checkToken"+                                                                                                               in let !(#+                                                                                                                         c,+                                                                                                                         cs+                                                                                                                         #) = readNext inp+                                                                                                                   in if (GHC.Classes.==) 'b' c+                                                                                                                        then+                                                                                                                          let _ = "lift2Value checkedHorizon=2"+                                                                                                                           in let _ = "commit"+                                                                                                                               in let _ = "resume"+                                                                                                                                   in join+                                                                                                                                        farInp+                                                                                                                                        farExp+                                                                                                                                        ( let _ = "resume.genCode"+                                                                                                                                           in 'b'+                                                                                                                                        )+                                                                                                                                        cs+                                                                                                                        else+                                                                                                                          let _ = "checkToken.fail"+                                                                                                                           in let failExp =+                                                                                                                                    Data.Set.Internal.Bin+                                                                                                                                      1+                                                                                                                                      ( Symantic.Parser.Grammar.Combinators.SomeFailure+                                                                                                                                          ( case inputToken of+                                                                                                                                              (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken 'b'+                                                                                                                                          )+                                                                                                                                      )+                                                                                                                                      Data.Set.Internal.Tip+                                                                                                                                      Data.Set.Internal.Tip+                                                                                                                               in let (#+                                                                                                                                        farInp,+                                                                                                                                        farExp+                                                                                                                                        #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp inp of+                                                                                                                                          GHC.Types.LT ->+                                                                                                                                            (#+                                                                                                                                              inp,+                                                                                                                                              failExp+                                                                                                                                            #)+                                                                                                                                          GHC.Types.EQ ->+                                                                                                                                            (#+                                                                                                                                              farInp,+                                                                                                                                              failExp GHC.Base.<> farExp+                                                                                                                                            #)+                                                                                                                                          GHC.Types.GT ->+                                                                                                                                            (#+                                                                                                                                              farInp,+                                                                                                                                              farExp+                                                                                                                                            #)+                                                                                                                                   in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp+                                                                                                            else+                                                                                                              let _ = "checkHorizon.newCheck.fail"+                                                                                                               in let failExp =+                                                                                                                        Data.Set.Internal.Bin+                                                                                                                          1+                                                                                                                          ( Symantic.Parser.Grammar.Combinators.SomeFailure+                                                                                                                              ( case inputToken of+                                                                                                                                  (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureHorizon @tok' 2+                                                                                                                              )+                                                                                                                          )+                                                                                                                          Data.Set.Internal.Tip+                                                                                                                          Data.Set.Internal.Tip+                                                                                                                   in let (#+                                                                                                                            farInp,+                                                                                                                            farExp+                                                                                                                            #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp inp of+                                                                                                                              GHC.Types.LT ->+                                                                                                                                (#+                                                                                                                                  inp,+                                                                                                                                  failExp+                                                                                                                                #)+                                                                                                                              GHC.Types.EQ ->+                                                                                                                                (#+                                                                                                                                  farInp,+                                                                                                                                  failExp GHC.Base.<> farExp+                                                                                                                                #)+                                                                                                                              GHC.Types.GT ->+                                                                                                                                (#+                                                                                                                                  farInp,+                                                                                                                                  farExp+                                                                                                                                #)+                                                                                                                       in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp+                                                                        else+                                                                          let _ = "choicesBranch.else"+                                                                           in finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp farInp farExp+                                               in let _ = "pushValue"+                                                   in let _ = "comment: satisfy ((GHC.Classes.==) 'a')"+                                                       in let _ = "checkHorizon.oldCheck: checkedHorizon=2"+                                                           in let _ = "checkToken"+                                                               in let !(#+                                                                         c,+                                                                         cs+                                                                         #) = readNext inp+                                                                   in if (GHC.Classes.==) 'a' c+                                                                        then+                                                                          let _ = "lift2Value checkedHorizon=1"+                                                                           in let _ = "commit"+                                                                               in let _ = "resume"+                                                                                   in join+                                                                                        init+                                                                                        Data.Set.Internal.empty+                                                                                        ( let _ = "resume.genCode"+                                                                                           in 'a'+                                                                                        )+                                                                                        cs+                                                                        else+                                                                          let _ = "checkToken.fail"+                                                                           in let failExp =+                                                                                    Data.Set.Internal.Bin+                                                                                      1+                                                                                      ( Symantic.Parser.Grammar.Combinators.SomeFailure+                                                                                          ( case inputToken of+                                                                                              (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken 'a'+                                                                                          )+                                                                                      )+                                                                                      Data.Set.Internal.Tip+                                                                                      Data.Set.Internal.Tip+                                                                               in let (#+                                                                                        farInp,+                                                                                        farExp+                                                                                        #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init inp of+                                                                                          GHC.Types.LT ->+                                                                                            (#+                                                                                              inp,+                                                                                              failExp+                                                                                            #)+                                                                                          GHC.Types.EQ ->+                                                                                            (#+                                                                                              init,+                                                                                              failExp GHC.Base.<> Data.Set.Internal.empty+                                                                                            #)+                                                                                          GHC.Types.GT ->+                                                                                            (#+                                                                                              init,+                                                                                              Data.Set.Internal.empty+                                                                                            #)+                                                                                   in onException Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp+                            else+                              let _ = "checkHorizon.newCheck.fail"+                               in let failExp =+                                        Data.Set.Internal.Bin+                                          1+                                          ( Symantic.Parser.Grammar.Combinators.SomeFailure+                                              ( case inputToken of+                                                  (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureHorizon @tok' 2+                                              )+                                          )+                                          Data.Set.Internal.Tip+                                          Data.Set.Internal.Tip+                                   in let (#+                                            farInp,+                                            farExp+                                            #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init inp of+                                              GHC.Types.LT ->+                                                (#+                                                  inp,+                                                  failExp+                                                #)+                                              GHC.Types.EQ ->+                                                (#+                                                  init,+                                                  failExp GHC.Base.<> Data.Set.Internal.empty+                                                #)+                                              GHC.Types.GT ->+                                                (#+                                                  init,+                                                  Data.Set.Internal.empty+                                                #)+                                       in finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp+        )
+ tests/Golden/Splice/G17.expected.txt view
@@ -0,0 +1,153 @@+\(input :: inp) ->+  let !(#+         init,+         readMore,+         readNext+         #) =+          let _ = "cursorOf"+           in let next+                    ( t@( Data.Text.Internal.Text+                            arr+                            off+                            unconsumed+                          )+                      ) =+                      let !( Data.Text.Unsafe.Iter+                               c+                               d+                             ) = Data.Text.Unsafe.iter t 0+                       in (#+                            c,+                            Data.Text.Internal.Text arr (off GHC.Num.+ d) (unconsumed GHC.Num.- d)+                          #)+                  more+                    ( Data.Text.Internal.Text+                        _+                        _+                        unconsumed+                      ) = unconsumed GHC.Classes.> 0+               in (# input, more, next #)+      finalRet = \_farInp _farExp v _inp -> Symantic.Parser.Machine.Generate.returnST GHC.Base.$ Data.Either.Right v+      finalRaise ::+        forall st b.+        Symantic.Parser.Machine.Generate.OnException+          st+          inp+          b = \(!exn) _failInp (!farInp) (!farExp) ->+          Symantic.Parser.Machine.Generate.returnST GHC.Base.$+            Data.Either.Left+              Symantic.Parser.Machine.Generate.ParsingError+                { Symantic.Parser.Machine.Generate.parsingErrorOffset = Symantic.Parser.Machine.Input.offset farInp,+                  Symantic.Parser.Machine.Generate.parsingErrorException = exn,+                  Symantic.Parser.Machine.Generate.parsingErrorUnexpected =+                    if readMore farInp+                      then+                        GHC.Maybe.Just+                          ( let (#+                                  c,+                                  _+                                  #) = readNext farInp+                             in c+                          )+                      else GHC.Maybe.Nothing,+                  Symantic.Parser.Machine.Generate.parsingErrorExpecting =+                    let ( minHoriz,+                          res+                          ) =+                            Data.Set.Internal.foldr+                              ( \f+                                 ( minH,+                                   acc+                                   ) -> case Symantic.Parser.Grammar.Combinators.unSomeFailure f of+                                    GHC.Maybe.Just (Symantic.Parser.Grammar.Combinators.FailureHorizon h :: Symantic.Parser.Grammar.Combinators.Failure (Symantic.Parser.Grammar.Combinators.CombSatisfiable (Symantic.Parser.Machine.Input.InputToken inp)))+                                      | GHC.Maybe.Just old <- minH ->+                                        ( GHC.Maybe.Just (GHC.Classes.min old h),+                                          acc+                                        )+                                      | GHC.Base.otherwise ->+                                        ( GHC.Maybe.Just h,+                                          acc+                                        )+                                    _ ->+                                      ( minH,+                                        f GHC.Types.: acc+                                      )+                              )+                              ( GHC.Maybe.Nothing,+                                GHC.Types . []+                              )+                              farExp+                     in Data.Set.Internal.fromList GHC.Base.$+                          ( case minHoriz of+                              GHC.Maybe.Just h -> Symantic.Parser.Grammar.Combinators.SomeFailure (Symantic.Parser.Grammar.Combinators.FailureHorizon @(Symantic.Parser.Machine.Input.InputToken inp) h) GHC.Types.: res+                              GHC.Maybe.Nothing -> res+                          )+                }+   in GHC.ST.runST+        ( let inputToken = Data.Proxy.Proxy :: Data.Proxy.Proxy (Symantic.Parser.Machine.Input.InputToken inp)+           in let inp = init+               in let readFail = finalRaise+                   in let _ = "checkHorizon.newCheck: checkedHorizon=0 minHoriz=1"+                       in if readMore inp+                            then+                              let+                               in let _ = "pushValue"+                                   in let _ = "comment: satisfy ((\\x_0 -> \\x_1 -> x_0) GHC.Types.True)"+                                       in let _ = "checkHorizon.oldCheck: checkedHorizon=1"+                                           in let _ = "checkToken"+                                               in let !(#+                                                         c,+                                                         cs+                                                         #) = readNext inp+                                                   in do+                                                        let dupv = c+                                                        reg <- GHC.STRef.newSTRef dupv+                                                        let _ = "pushValue"+                                                         in do+                                                              sr <- GHC.STRef.readSTRef reg+                                                              let _ = "lift2Value checkedHorizon=0"+                                                               in do+                                                                    sr <- GHC.STRef.readSTRef reg+                                                                    let _ = "lift2Value checkedHorizon=0"+                                                                     in let _ = "lift2Value checkedHorizon=0"+                                                                         in let _ = "resume"+                                                                             in finalRet+                                                                                  init+                                                                                  Data.Set.Internal.empty+                                                                                  ( let _ = "resume.genCode"+                                                                                     in GHC.Show.show (GHC.Tuple . (,) sr sr)+                                                                                  )+                                                                                  cs+                            else+                              let _ = "checkHorizon.newCheck.fail"+                               in let failExp =+                                        Data.Set.Internal.Bin+                                          1+                                          ( Symantic.Parser.Grammar.Combinators.SomeFailure+                                              ( case inputToken of+                                                  (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureHorizon @tok' 1+                                              )+                                          )+                                          Data.Set.Internal.Tip+                                          Data.Set.Internal.Tip+                                   in let (#+                                            farInp,+                                            farExp+                                            #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init inp of+                                              GHC.Types.LT ->+                                                (#+                                                  inp,+                                                  failExp+                                                #)+                                              GHC.Types.EQ ->+                                                (#+                                                  init,+                                                  failExp GHC.Base.<> Data.Set.Internal.empty+                                                #)+                                              GHC.Types.GT ->+                                                (#+                                                  init,+                                                  Data.Set.Internal.empty+                                                #)+                                       in finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp+        )
+ tests/Golden/Splice/G18.expected.txt view
@@ -0,0 +1,479 @@+\(input :: inp) ->+  let !(#+         init,+         readMore,+         readNext+         #) =+          let _ = "cursorOf"+           in let next+                    ( t@( Data.Text.Internal.Text+                            arr+                            off+                            unconsumed+                          )+                      ) =+                      let !( Data.Text.Unsafe.Iter+                               c+                               d+                             ) = Data.Text.Unsafe.iter t 0+                       in (#+                            c,+                            Data.Text.Internal.Text arr (off GHC.Num.+ d) (unconsumed GHC.Num.- d)+                          #)+                  more+                    ( Data.Text.Internal.Text+                        _+                        _+                        unconsumed+                      ) = unconsumed GHC.Classes.> 0+               in (# input, more, next #)+      finalRet = \_farInp _farExp v _inp -> Symantic.Parser.Machine.Generate.returnST GHC.Base.$ Data.Either.Right v+      finalRaise ::+        forall st b.+        Symantic.Parser.Machine.Generate.OnException+          st+          inp+          b = \(!exn) _failInp (!farInp) (!farExp) ->+          Symantic.Parser.Machine.Generate.returnST GHC.Base.$+            Data.Either.Left+              Symantic.Parser.Machine.Generate.ParsingError+                { Symantic.Parser.Machine.Generate.parsingErrorOffset = Symantic.Parser.Machine.Input.offset farInp,+                  Symantic.Parser.Machine.Generate.parsingErrorException = exn,+                  Symantic.Parser.Machine.Generate.parsingErrorUnexpected =+                    if readMore farInp+                      then+                        GHC.Maybe.Just+                          ( let (#+                                  c,+                                  _+                                  #) = readNext farInp+                             in c+                          )+                      else GHC.Maybe.Nothing,+                  Symantic.Parser.Machine.Generate.parsingErrorExpecting =+                    let ( minHoriz,+                          res+                          ) =+                            Data.Set.Internal.foldr+                              ( \f+                                 ( minH,+                                   acc+                                   ) -> case Symantic.Parser.Grammar.Combinators.unSomeFailure f of+                                    GHC.Maybe.Just (Symantic.Parser.Grammar.Combinators.FailureHorizon h :: Symantic.Parser.Grammar.Combinators.Failure (Symantic.Parser.Grammar.Combinators.CombSatisfiable (Symantic.Parser.Machine.Input.InputToken inp)))+                                      | GHC.Maybe.Just old <- minH ->+                                        ( GHC.Maybe.Just (GHC.Classes.min old h),+                                          acc+                                        )+                                      | GHC.Base.otherwise ->+                                        ( GHC.Maybe.Just h,+                                          acc+                                        )+                                    _ ->+                                      ( minH,+                                        f GHC.Types.: acc+                                      )+                              )+                              ( GHC.Maybe.Nothing,+                                GHC.Types . []+                              )+                              farExp+                     in Data.Set.Internal.fromList GHC.Base.$+                          ( case minHoriz of+                              GHC.Maybe.Just h -> Symantic.Parser.Grammar.Combinators.SomeFailure (Symantic.Parser.Grammar.Combinators.FailureHorizon @(Symantic.Parser.Machine.Input.InputToken inp) h) GHC.Types.: res+                              GHC.Maybe.Nothing -> res+                          )+                }+   in GHC.ST.runST+        ( let inputToken = Data.Proxy.Proxy :: Data.Proxy.Proxy (Symantic.Parser.Machine.Input.InputToken inp)+           in let inp = init+               in let readFail = finalRaise+                   in let _ = "checkHorizon.newCheck: checkedHorizon=0 minHoriz=2"+                       in if readMore (Symantic.Parser.Machine.Input.shiftRightText 1 inp)+                            then+                              let+                               in let _ = "pushValue"+                                   in let join = \farInp farExp v (!inp) ->+                                            let _ = "lift2Value checkedHorizon=0"+                                             in let _ = "resume"+                                                 in finalRet+                                                      farInp+                                                      farExp+                                                      ( let _ = "resume.genCode"+                                                         in GHC.Show.show v+                                                      )+                                                      inp+                                       in let _ = "catch ExceptionFailure checkedHorizon=2"+                                           in let onException =+                                                    let _ = "onException"+                                                     in \(!_exn) (!failInp) (!farInp) (!farExp) ->+                                                          let _ = "comment: raiseAgainIfConsumed"+                                                           in let _ = "saveInput checkedHorizon=0"+                                                               in let _ = "lift2Value checkedHorizon=0"+                                                                   in if ( \( Data.Text.Internal.Text+                                                                                _+                                                                                i+                                                                                _+                                                                              )+                                                                            ( Data.Text.Internal.Text+                                                                                _+                                                                                j+                                                                                _+                                                                              ) -> i GHC.Classes.== j+                                                                         )+                                                                        inp+                                                                        failInp+                                                                        then+                                                                          let _ = "choicesBranch checkedHorizon=0"+                                                                           in let _ = "catch ExceptionFailure checkedHorizon=0"+                                                                               in let onException =+                                                                                        let _ = "onException"+                                                                                         in \(!_exn) (!failInp) (!farInp) (!farExp) ->+                                                                                              let _ = "loadInput checkedHorizon=0"+                                                                                               in let _ = "checkHorizon.noCheck"+                                                                                                   in finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp farInp farExp+                                                                                   in let _ = "pushValue"+                                                                                       in let _ = "comment: satisfy ((GHC.Classes.==) 'd')"+                                                                                           in let inp = failInp+                                                                                               in let readFail = onException+                                                                                                   in let _ = "checkHorizon.newCheck: checkedHorizon=0 minHoriz=2"+                                                                                                       in if readMore (Symantic.Parser.Machine.Input.shiftRightText 1 inp)+                                                                                                            then+                                                                                                              let _ = "checkToken"+                                                                                                               in let !(#+                                                                                                                         c,+                                                                                                                         cs+                                                                                                                         #) = readNext inp+                                                                                                                   in if (GHC.Classes.==) 'd' c+                                                                                                                        then+                                                                                                                          let _ = "lift2Value checkedHorizon=2"+                                                                                                                           in let _ = "comment: satisfy ((GHC.Classes.==) 'e')"+                                                                                                                               in let _ = "checkHorizon.oldCheck: checkedHorizon=2"+                                                                                                                                   in let _ = "checkToken"+                                                                                                                                       in let !(#+                                                                                                                                                 c,+                                                                                                                                                 cs+                                                                                                                                                 #) = readNext cs+                                                                                                                                           in if (GHC.Classes.==) 'e' c+                                                                                                                                                then+                                                                                                                                                  let _ = "lift2Value checkedHorizon=1"+                                                                                                                                                   in let _ = "commit"+                                                                                                                                                       in let _ = "resume"+                                                                                                                                                           in join+                                                                                                                                                                farInp+                                                                                                                                                                farExp+                                                                                                                                                                ( let _ = "resume.genCode"+                                                                                                                                                                   in (GHC.Types.:) 'd' ((GHC.Types.:) 'e' GHC.Types . [])+                                                                                                                                                                )+                                                                                                                                                                cs+                                                                                                                                                else+                                                                                                                                                  let _ = "checkToken.fail"+                                                                                                                                                   in let failExp =+                                                                                                                                                            Data.Set.Internal.Bin+                                                                                                                                                              1+                                                                                                                                                              ( Symantic.Parser.Grammar.Combinators.SomeFailure+                                                                                                                                                                  ( case inputToken of+                                                                                                                                                                      (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken 'e'+                                                                                                                                                                  )+                                                                                                                                                              )+                                                                                                                                                              Data.Set.Internal.Tip+                                                                                                                                                              Data.Set.Internal.Tip+                                                                                                                                                       in let (#+                                                                                                                                                                farInp,+                                                                                                                                                                farExp+                                                                                                                                                                #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp cs of+                                                                                                                                                                  GHC.Types.LT ->+                                                                                                                                                                    (#+                                                                                                                                                                      cs,+                                                                                                                                                                      failExp+                                                                                                                                                                    #)+                                                                                                                                                                  GHC.Types.EQ ->+                                                                                                                                                                    (#+                                                                                                                                                                      farInp,+                                                                                                                                                                      failExp GHC.Base.<> farExp+                                                                                                                                                                    #)+                                                                                                                                                                  GHC.Types.GT ->+                                                                                                                                                                    (#+                                                                                                                                                                      farInp,+                                                                                                                                                                      farExp+                                                                                                                                                                    #)+                                                                                                                                                           in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure cs farInp farExp+                                                                                                                        else+                                                                                                                          let _ = "checkToken.fail"+                                                                                                                           in let failExp =+                                                                                                                                    Data.Set.Internal.Bin+                                                                                                                                      1+                                                                                                                                      ( Symantic.Parser.Grammar.Combinators.SomeFailure+                                                                                                                                          ( case inputToken of+                                                                                                                                              (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken 'd'+                                                                                                                                          )+                                                                                                                                      )+                                                                                                                                      Data.Set.Internal.Tip+                                                                                                                                      Data.Set.Internal.Tip+                                                                                                                               in let (#+                                                                                                                                        farInp,+                                                                                                                                        farExp+                                                                                                                                        #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp inp of+                                                                                                                                          GHC.Types.LT ->+                                                                                                                                            (#+                                                                                                                                              inp,+                                                                                                                                              failExp+                                                                                                                                            #)+                                                                                                                                          GHC.Types.EQ ->+                                                                                                                                            (#+                                                                                                                                              farInp,+                                                                                                                                              failExp GHC.Base.<> farExp+                                                                                                                                            #)+                                                                                                                                          GHC.Types.GT ->+                                                                                                                                            (#+                                                                                                                                              farInp,+                                                                                                                                              farExp+                                                                                                                                            #)+                                                                                                                                   in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp+                                                                                                            else+                                                                                                              let _ = "checkHorizon.newCheck.fail"+                                                                                                               in let failExp =+                                                                                                                        Data.Set.Internal.Bin+                                                                                                                          1+                                                                                                                          ( Symantic.Parser.Grammar.Combinators.SomeFailure+                                                                                                                              ( case inputToken of+                                                                                                                                  (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureHorizon @tok' 2+                                                                                                                              )+                                                                                                                          )+                                                                                                                          Data.Set.Internal.Tip+                                                                                                                          Data.Set.Internal.Tip+                                                                                                                   in let (#+                                                                                                                            farInp,+                                                                                                                            farExp+                                                                                                                            #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp inp of+                                                                                                                              GHC.Types.LT ->+                                                                                                                                (#+                                                                                                                                  inp,+                                                                                                                                  failExp+                                                                                                                                #)+                                                                                                                              GHC.Types.EQ ->+                                                                                                                                (#+                                                                                                                                  farInp,+                                                                                                                                  failExp GHC.Base.<> farExp+                                                                                                                                #)+                                                                                                                              GHC.Types.GT ->+                                                                                                                                (#+                                                                                                                                  farInp,+                                                                                                                                  farExp+                                                                                                                                #)+                                                                                                                       in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp+                                                                        else+                                                                          let _ = "choicesBranch.else"+                                                                           in finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp farInp farExp+                                               in let _ = "catch ExceptionFailure checkedHorizon=2"+                                                   in let onException =+                                                            let _ = "onException"+                                                             in \(!_exn) (!failInp) (!farInp) (!farExp) ->+                                                                  let _ = "loadInput checkedHorizon=2"+                                                                   in let _ = "checkHorizon.oldCheck: checkedHorizon=2"+                                                                       in onException Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp+                                                       in let _ = "pushValue"+                                                           in let _ = "comment: satisfy ((GHC.Classes.==) 'a')"+                                                               in let _ = "checkHorizon.oldCheck: checkedHorizon=2"+                                                                   in let _ = "checkToken"+                                                                       in let !(#+                                                                                 c,+                                                                                 cs+                                                                                 #) = readNext inp+                                                                           in if (GHC.Classes.==) 'a' c+                                                                                then+                                                                                  let _ = "lift2Value checkedHorizon=1"+                                                                                   in let _ = "comment: satisfy ((GHC.Classes.==) 'b')"+                                                                                       in let _ = "checkHorizon.oldCheck: checkedHorizon=1"+                                                                                           in let _ = "checkToken"+                                                                                               in let !(#+                                                                                                         c,+                                                                                                         cs+                                                                                                         #) = readNext cs+                                                                                                   in if (GHC.Classes.==) 'b' c+                                                                                                        then+                                                                                                          let _ = "lift2Value checkedHorizon=0"+                                                                                                           in let _ = "comment: satisfy ((GHC.Classes.==) 'c')"+                                                                                                               in let inp = cs+                                                                                                                   in let readFail = onException+                                                                                                                       in let _ = "checkHorizon.newCheck: checkedHorizon=0 minHoriz=1"+                                                                                                                           in if readMore inp+                                                                                                                                then+                                                                                                                                  let _ = "checkToken"+                                                                                                                                   in let !(#+                                                                                                                                             c,+                                                                                                                                             cs+                                                                                                                                             #) = readNext inp+                                                                                                                                       in if (GHC.Classes.==) 'c' c+                                                                                                                                            then+                                                                                                                                              let _ = "lift2Value checkedHorizon=1"+                                                                                                                                               in let _ = "commit"+                                                                                                                                                   in let _ = "commit"+                                                                                                                                                       in let _ = "resume"+                                                                                                                                                           in join+                                                                                                                                                                init+                                                                                                                                                                Data.Set.Internal.empty+                                                                                                                                                                ( let _ = "resume.genCode"+                                                                                                                                                                   in (GHC.Types.:) 'a' ((GHC.Types.:) 'b' ((GHC.Types.:) 'c' GHC.Types . []))+                                                                                                                                                                )+                                                                                                                                                                cs+                                                                                                                                            else+                                                                                                                                              let _ = "checkToken.fail"+                                                                                                                                               in let failExp =+                                                                                                                                                        Data.Set.Internal.Bin+                                                                                                                                                          1+                                                                                                                                                          ( Symantic.Parser.Grammar.Combinators.SomeFailure+                                                                                                                                                              ( case inputToken of+                                                                                                                                                                  (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken 'c'+                                                                                                                                                              )+                                                                                                                                                          )+                                                                                                                                                          Data.Set.Internal.Tip+                                                                                                                                                          Data.Set.Internal.Tip+                                                                                                                                                   in let (#+                                                                                                                                                            farInp,+                                                                                                                                                            farExp+                                                                                                                                                            #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init inp of+                                                                                                                                                              GHC.Types.LT ->+                                                                                                                                                                (#+                                                                                                                                                                  inp,+                                                                                                                                                                  failExp+                                                                                                                                                                #)+                                                                                                                                                              GHC.Types.EQ ->+                                                                                                                                                                (#+                                                                                                                                                                  init,+                                                                                                                                                                  failExp GHC.Base.<> Data.Set.Internal.empty+                                                                                                                                                                #)+                                                                                                                                                              GHC.Types.GT ->+                                                                                                                                                                (#+                                                                                                                                                                  init,+                                                                                                                                                                  Data.Set.Internal.empty+                                                                                                                                                                #)+                                                                                                                                                       in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp+                                                                                                                                else+                                                                                                                                  let _ = "checkHorizon.newCheck.fail"+                                                                                                                                   in let failExp =+                                                                                                                                            Data.Set.Internal.Bin+                                                                                                                                              1+                                                                                                                                              ( Symantic.Parser.Grammar.Combinators.SomeFailure+                                                                                                                                                  ( case inputToken of+                                                                                                                                                      (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureHorizon @tok' 1+                                                                                                                                                  )+                                                                                                                                              )+                                                                                                                                              Data.Set.Internal.Tip+                                                                                                                                              Data.Set.Internal.Tip+                                                                                                                                       in let (#+                                                                                                                                                farInp,+                                                                                                                                                farExp+                                                                                                                                                #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init inp of+                                                                                                                                                  GHC.Types.LT ->+                                                                                                                                                    (#+                                                                                                                                                      inp,+                                                                                                                                                      failExp+                                                                                                                                                    #)+                                                                                                                                                  GHC.Types.EQ ->+                                                                                                                                                    (#+                                                                                                                                                      init,+                                                                                                                                                      failExp GHC.Base.<> Data.Set.Internal.empty+                                                                                                                                                    #)+                                                                                                                                                  GHC.Types.GT ->+                                                                                                                                                    (#+                                                                                                                                                      init,+                                                                                                                                                      Data.Set.Internal.empty+                                                                                                                                                    #)+                                                                                                                                           in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp+                                                                                                        else+                                                                                                          let _ = "checkToken.fail"+                                                                                                           in let failExp =+                                                                                                                    Data.Set.Internal.Bin+                                                                                                                      1+                                                                                                                      ( Symantic.Parser.Grammar.Combinators.SomeFailure+                                                                                                                          ( case inputToken of+                                                                                                                              (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken 'b'+                                                                                                                          )+                                                                                                                      )+                                                                                                                      Data.Set.Internal.Tip+                                                                                                                      Data.Set.Internal.Tip+                                                                                                               in let (#+                                                                                                                        farInp,+                                                                                                                        farExp+                                                                                                                        #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init cs of+                                                                                                                          GHC.Types.LT ->+                                                                                                                            (#+                                                                                                                              cs,+                                                                                                                              failExp+                                                                                                                            #)+                                                                                                                          GHC.Types.EQ ->+                                                                                                                            (#+                                                                                                                              init,+                                                                                                                              failExp GHC.Base.<> Data.Set.Internal.empty+                                                                                                                            #)+                                                                                                                          GHC.Types.GT ->+                                                                                                                            (#+                                                                                                                              init,+                                                                                                                              Data.Set.Internal.empty+                                                                                                                            #)+                                                                                                                   in onException Symantic.Parser.Grammar.Combinators.ExceptionFailure cs farInp farExp+                                                                                else+                                                                                  let _ = "checkToken.fail"+                                                                                   in let failExp =+                                                                                            Data.Set.Internal.Bin+                                                                                              1+                                                                                              ( Symantic.Parser.Grammar.Combinators.SomeFailure+                                                                                                  ( case inputToken of+                                                                                                      (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken 'a'+                                                                                                  )+                                                                                              )+                                                                                              Data.Set.Internal.Tip+                                                                                              Data.Set.Internal.Tip+                                                                                       in let (#+                                                                                                farInp,+                                                                                                farExp+                                                                                                #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init inp of+                                                                                                  GHC.Types.LT ->+                                                                                                    (#+                                                                                                      inp,+                                                                                                      failExp+                                                                                                    #)+                                                                                                  GHC.Types.EQ ->+                                                                                                    (#+                                                                                                      init,+                                                                                                      failExp GHC.Base.<> Data.Set.Internal.empty+                                                                                                    #)+                                                                                                  GHC.Types.GT ->+                                                                                                    (#+                                                                                                      init,+                                                                                                      Data.Set.Internal.empty+                                                                                                    #)+                                                                                           in onException Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp+                            else+                              let _ = "checkHorizon.newCheck.fail"+                               in let failExp =+                                        Data.Set.Internal.Bin+                                          1+                                          ( Symantic.Parser.Grammar.Combinators.SomeFailure+                                              ( case inputToken of+                                                  (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureHorizon @tok' 2+                                              )+                                          )+                                          Data.Set.Internal.Tip+                                          Data.Set.Internal.Tip+                                   in let (#+                                            farInp,+                                            farExp+                                            #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init inp of+                                              GHC.Types.LT ->+                                                (#+                                                  inp,+                                                  failExp+                                                #)+                                              GHC.Types.EQ ->+                                                (#+                                                  init,+                                                  failExp GHC.Base.<> Data.Set.Internal.empty+                                                #)+                                              GHC.Types.GT ->+                                                (#+                                                  init,+                                                  Data.Set.Internal.empty+                                                #)+                                       in finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp+        )
+ tests/Golden/Splice/G19.expected.txt view
@@ -0,0 +1,726 @@+\(input :: inp) ->+  let !(#+         init,+         readMore,+         readNext+         #) =+          let _ = "cursorOf"+           in let next+                    ( t@( Data.Text.Internal.Text+                            arr+                            off+                            unconsumed+                          )+                      ) =+                      let !( Data.Text.Unsafe.Iter+                               c+                               d+                             ) = Data.Text.Unsafe.iter t 0+                       in (#+                            c,+                            Data.Text.Internal.Text arr (off GHC.Num.+ d) (unconsumed GHC.Num.- d)+                          #)+                  more+                    ( Data.Text.Internal.Text+                        _+                        _+                        unconsumed+                      ) = unconsumed GHC.Classes.> 0+               in (# input, more, next #)+      finalRet = \_farInp _farExp v _inp -> Symantic.Parser.Machine.Generate.returnST GHC.Base.$ Data.Either.Right v+      finalRaise ::+        forall st b.+        Symantic.Parser.Machine.Generate.OnException+          st+          inp+          b = \(!exn) _failInp (!farInp) (!farExp) ->+          Symantic.Parser.Machine.Generate.returnST GHC.Base.$+            Data.Either.Left+              Symantic.Parser.Machine.Generate.ParsingError+                { Symantic.Parser.Machine.Generate.parsingErrorOffset = Symantic.Parser.Machine.Input.offset farInp,+                  Symantic.Parser.Machine.Generate.parsingErrorException = exn,+                  Symantic.Parser.Machine.Generate.parsingErrorUnexpected =+                    if readMore farInp+                      then+                        GHC.Maybe.Just+                          ( let (#+                                  c,+                                  _+                                  #) = readNext farInp+                             in c+                          )+                      else GHC.Maybe.Nothing,+                  Symantic.Parser.Machine.Generate.parsingErrorExpecting =+                    let ( minHoriz,+                          res+                          ) =+                            Data.Set.Internal.foldr+                              ( \f+                                 ( minH,+                                   acc+                                   ) -> case Symantic.Parser.Grammar.Combinators.unSomeFailure f of+                                    GHC.Maybe.Just (Symantic.Parser.Grammar.Combinators.FailureHorizon h :: Symantic.Parser.Grammar.Combinators.Failure (Symantic.Parser.Grammar.Combinators.CombSatisfiable (Symantic.Parser.Machine.Input.InputToken inp)))+                                      | GHC.Maybe.Just old <- minH ->+                                        ( GHC.Maybe.Just (GHC.Classes.min old h),+                                          acc+                                        )+                                      | GHC.Base.otherwise ->+                                        ( GHC.Maybe.Just h,+                                          acc+                                        )+                                    _ ->+                                      ( minH,+                                        f GHC.Types.: acc+                                      )+                              )+                              ( GHC.Maybe.Nothing,+                                GHC.Types . []+                              )+                              farExp+                     in Data.Set.Internal.fromList GHC.Base.$+                          ( case minHoriz of+                              GHC.Maybe.Just h -> Symantic.Parser.Grammar.Combinators.SomeFailure (Symantic.Parser.Grammar.Combinators.FailureHorizon @(Symantic.Parser.Machine.Input.InputToken inp) h) GHC.Types.: res+                              GHC.Maybe.Nothing -> res+                          )+                }+   in GHC.ST.runST+        ( let inputToken = Data.Proxy.Proxy :: Data.Proxy.Proxy (Symantic.Parser.Machine.Input.InputToken inp)+           in let inp = init+               in let readFail = finalRaise+                   in let _ = "checkHorizon.newCheck: checkedHorizon=0 minHoriz=2"+                       in if readMore (Symantic.Parser.Machine.Input.shiftRightText 1 inp)+                            then+                              let+                               in let _ = "pushValue"+                                   in let join = \farInp farExp v (!inp) ->+                                            let _ = "lift2Value checkedHorizon=0"+                                             in let _ = "resume"+                                                 in finalRet+                                                      farInp+                                                      farExp+                                                      ( let _ = "resume.genCode"+                                                         in GHC.Show.show v+                                                      )+                                                      inp+                                       in let _ = "catch ExceptionFailure checkedHorizon=2"+                                           in let onException =+                                                    let _ = "onException"+                                                     in \(!_exn) (!failInp) (!farInp) (!farExp) ->+                                                          let _ = "comment: raiseAgainIfConsumed"+                                                           in let _ = "saveInput checkedHorizon=0"+                                                               in let _ = "lift2Value checkedHorizon=0"+                                                                   in if ( \( Data.Text.Internal.Text+                                                                                _+                                                                                i+                                                                                _+                                                                              )+                                                                            ( Data.Text.Internal.Text+                                                                                _+                                                                                j+                                                                                _+                                                                              ) -> i GHC.Classes.== j+                                                                         )+                                                                        inp+                                                                        failInp+                                                                        then+                                                                          let _ = "choicesBranch checkedHorizon=0"+                                                                           in let _ = "catch ExceptionFailure checkedHorizon=0"+                                                                               in let onException =+                                                                                        let _ = "onException"+                                                                                         in \(!_exn) (!failInp) (!farInp) (!farExp) ->+                                                                                              let _ = "comment: raiseAgainIfConsumed"+                                                                                               in let _ = "saveInput checkedHorizon=0"+                                                                                                   in let _ = "lift2Value checkedHorizon=0"+                                                                                                       in if ( \( Data.Text.Internal.Text+                                                                                                                    _+                                                                                                                    i+                                                                                                                    _+                                                                                                                  )+                                                                                                                ( Data.Text.Internal.Text+                                                                                                                    _+                                                                                                                    j+                                                                                                                    _+                                                                                                                  ) -> i GHC.Classes.== j+                                                                                                             )+                                                                                                            failInp+                                                                                                            failInp+                                                                                                            then+                                                                                                              let _ = "choicesBranch checkedHorizon=0"+                                                                                                               in let _ = "catch ExceptionFailure checkedHorizon=0"+                                                                                                                   in let onException =+                                                                                                                            let _ = "onException"+                                                                                                                             in \(!_exn) (!failInp) (!farInp) (!farExp) ->+                                                                                                                                  let _ = "loadInput checkedHorizon=0"+                                                                                                                                   in let _ = "checkHorizon.noCheck"+                                                                                                                                       in finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp farInp farExp+                                                                                                                       in let _ = "pushValue"+                                                                                                                           in let _ = "comment: satisfy ((GHC.Classes.==) 'f')"+                                                                                                                               in let inp = failInp+                                                                                                                                   in let readFail = onException+                                                                                                                                       in let _ = "checkHorizon.newCheck: checkedHorizon=0 minHoriz=4"+                                                                                                                                           in if readMore (Symantic.Parser.Machine.Input.shiftRightText 3 inp)+                                                                                                                                                then+                                                                                                                                                  let _ = "checkToken"+                                                                                                                                                   in let !(#+                                                                                                                                                             c,+                                                                                                                                                             cs+                                                                                                                                                             #) = readNext inp+                                                                                                                                                       in if (GHC.Classes.==) 'f' c+                                                                                                                                                            then+                                                                                                                                                              let _ = "lift2Value checkedHorizon=4"+                                                                                                                                                               in let _ = "comment: satisfy ((GHC.Classes.==) 'g')"+                                                                                                                                                                   in let _ = "checkHorizon.oldCheck: checkedHorizon=4"+                                                                                                                                                                       in let _ = "checkToken"+                                                                                                                                                                           in let !(#+                                                                                                                                                                                     c,+                                                                                                                                                                                     cs+                                                                                                                                                                                     #) = readNext cs+                                                                                                                                                                               in if (GHC.Classes.==) 'g' c+                                                                                                                                                                                    then+                                                                                                                                                                                      let _ = "lift2Value checkedHorizon=3"+                                                                                                                                                                                       in let _ = "comment: satisfy ((GHC.Classes.==) 'h')"+                                                                                                                                                                                           in let _ = "checkHorizon.oldCheck: checkedHorizon=3"+                                                                                                                                                                                               in let _ = "checkToken"+                                                                                                                                                                                                   in let !(#+                                                                                                                                                                                                             c,+                                                                                                                                                                                                             cs+                                                                                                                                                                                                             #) = readNext cs+                                                                                                                                                                                                       in if (GHC.Classes.==) 'h' c+                                                                                                                                                                                                            then+                                                                                                                                                                                                              let _ = "lift2Value checkedHorizon=2"+                                                                                                                                                                                                               in let _ = "comment: satisfy ((GHC.Classes.==) 'i')"+                                                                                                                                                                                                                   in let _ = "checkHorizon.oldCheck: checkedHorizon=2"+                                                                                                                                                                                                                       in let _ = "checkToken"+                                                                                                                                                                                                                           in let !(#+                                                                                                                                                                                                                                     c,+                                                                                                                                                                                                                                     cs+                                                                                                                                                                                                                                     #) = readNext cs+                                                                                                                                                                                                                               in if (GHC.Classes.==) 'i' c+                                                                                                                                                                                                                                    then+                                                                                                                                                                                                                                      let _ = "lift2Value checkedHorizon=1"+                                                                                                                                                                                                                                       in let _ = "commit"+                                                                                                                                                                                                                                           in let _ = "resume"+                                                                                                                                                                                                                                               in join+                                                                                                                                                                                                                                                    farInp+                                                                                                                                                                                                                                                    farExp+                                                                                                                                                                                                                                                    ( let _ = "resume.genCode"+                                                                                                                                                                                                                                                       in (GHC.Types.:) 'f' ((GHC.Types.:) 'g' ((GHC.Types.:) 'h' ((GHC.Types.:) 'i' GHC.Types . [])))+                                                                                                                                                                                                                                                    )+                                                                                                                                                                                                                                                    cs+                                                                                                                                                                                                                                    else+                                                                                                                                                                                                                                      let _ = "checkToken.fail"+                                                                                                                                                                                                                                       in let failExp =+                                                                                                                                                                                                                                                Data.Set.Internal.Bin+                                                                                                                                                                                                                                                  1+                                                                                                                                                                                                                                                  ( Symantic.Parser.Grammar.Combinators.SomeFailure+                                                                                                                                                                                                                                                      ( case inputToken of+                                                                                                                                                                                                                                                          (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken 'i'+                                                                                                                                                                                                                                                      )+                                                                                                                                                                                                                                                  )+                                                                                                                                                                                                                                                  Data.Set.Internal.Tip+                                                                                                                                                                                                                                                  Data.Set.Internal.Tip+                                                                                                                                                                                                                                           in let (#+                                                                                                                                                                                                                                                    farInp,+                                                                                                                                                                                                                                                    farExp+                                                                                                                                                                                                                                                    #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp cs of+                                                                                                                                                                                                                                                      GHC.Types.LT ->+                                                                                                                                                                                                                                                        (#+                                                                                                                                                                                                                                                          cs,+                                                                                                                                                                                                                                                          failExp+                                                                                                                                                                                                                                                        #)+                                                                                                                                                                                                                                                      GHC.Types.EQ ->+                                                                                                                                                                                                                                                        (#+                                                                                                                                                                                                                                                          farInp,+                                                                                                                                                                                                                                                          failExp GHC.Base.<> farExp+                                                                                                                                                                                                                                                        #)+                                                                                                                                                                                                                                                      GHC.Types.GT ->+                                                                                                                                                                                                                                                        (#+                                                                                                                                                                                                                                                          farInp,+                                                                                                                                                                                                                                                          farExp+                                                                                                                                                                                                                                                        #)+                                                                                                                                                                                                                                               in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure cs farInp farExp+                                                                                                                                                                                                            else+                                                                                                                                                                                                              let _ = "checkToken.fail"+                                                                                                                                                                                                               in let failExp =+                                                                                                                                                                                                                        Data.Set.Internal.Bin+                                                                                                                                                                                                                          1+                                                                                                                                                                                                                          ( Symantic.Parser.Grammar.Combinators.SomeFailure+                                                                                                                                                                                                                              ( case inputToken of+                                                                                                                                                                                                                                  (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken 'h'+                                                                                                                                                                                                                              )+                                                                                                                                                                                                                          )+                                                                                                                                                                                                                          Data.Set.Internal.Tip+                                                                                                                                                                                                                          Data.Set.Internal.Tip+                                                                                                                                                                                                                   in let (#+                                                                                                                                                                                                                            farInp,+                                                                                                                                                                                                                            farExp+                                                                                                                                                                                                                            #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp cs of+                                                                                                                                                                                                                              GHC.Types.LT ->+                                                                                                                                                                                                                                (#+                                                                                                                                                                                                                                  cs,+                                                                                                                                                                                                                                  failExp+                                                                                                                                                                                                                                #)+                                                                                                                                                                                                                              GHC.Types.EQ ->+                                                                                                                                                                                                                                (#+                                                                                                                                                                                                                                  farInp,+                                                                                                                                                                                                                                  failExp GHC.Base.<> farExp+                                                                                                                                                                                                                                #)+                                                                                                                                                                                                                              GHC.Types.GT ->+                                                                                                                                                                                                                                (#+                                                                                                                                                                                                                                  farInp,+                                                                                                                                                                                                                                  farExp+                                                                                                                                                                                                                                #)+                                                                                                                                                                                                                       in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure cs farInp farExp+                                                                                                                                                                                    else+                                                                                                                                                                                      let _ = "checkToken.fail"+                                                                                                                                                                                       in let failExp =+                                                                                                                                                                                                Data.Set.Internal.Bin+                                                                                                                                                                                                  1+                                                                                                                                                                                                  ( Symantic.Parser.Grammar.Combinators.SomeFailure+                                                                                                                                                                                                      ( case inputToken of+                                                                                                                                                                                                          (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken 'g'+                                                                                                                                                                                                      )+                                                                                                                                                                                                  )+                                                                                                                                                                                                  Data.Set.Internal.Tip+                                                                                                                                                                                                  Data.Set.Internal.Tip+                                                                                                                                                                                           in let (#+                                                                                                                                                                                                    farInp,+                                                                                                                                                                                                    farExp+                                                                                                                                                                                                    #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp cs of+                                                                                                                                                                                                      GHC.Types.LT ->+                                                                                                                                                                                                        (#+                                                                                                                                                                                                          cs,+                                                                                                                                                                                                          failExp+                                                                                                                                                                                                        #)+                                                                                                                                                                                                      GHC.Types.EQ ->+                                                                                                                                                                                                        (#+                                                                                                                                                                                                          farInp,+                                                                                                                                                                                                          failExp GHC.Base.<> farExp+                                                                                                                                                                                                        #)+                                                                                                                                                                                                      GHC.Types.GT ->+                                                                                                                                                                                                        (#+                                                                                                                                                                                                          farInp,+                                                                                                                                                                                                          farExp+                                                                                                                                                                                                        #)+                                                                                                                                                                                               in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure cs farInp farExp+                                                                                                                                                            else+                                                                                                                                                              let _ = "checkToken.fail"+                                                                                                                                                               in let failExp =+                                                                                                                                                                        Data.Set.Internal.Bin+                                                                                                                                                                          1+                                                                                                                                                                          ( Symantic.Parser.Grammar.Combinators.SomeFailure+                                                                                                                                                                              ( case inputToken of+                                                                                                                                                                                  (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken 'f'+                                                                                                                                                                              )+                                                                                                                                                                          )+                                                                                                                                                                          Data.Set.Internal.Tip+                                                                                                                                                                          Data.Set.Internal.Tip+                                                                                                                                                                   in let (#+                                                                                                                                                                            farInp,+                                                                                                                                                                            farExp+                                                                                                                                                                            #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp inp of+                                                                                                                                                                              GHC.Types.LT ->+                                                                                                                                                                                (#+                                                                                                                                                                                  inp,+                                                                                                                                                                                  failExp+                                                                                                                                                                                #)+                                                                                                                                                                              GHC.Types.EQ ->+                                                                                                                                                                                (#+                                                                                                                                                                                  farInp,+                                                                                                                                                                                  failExp GHC.Base.<> farExp+                                                                                                                                                                                #)+                                                                                                                                                                              GHC.Types.GT ->+                                                                                                                                                                                (#+                                                                                                                                                                                  farInp,+                                                                                                                                                                                  farExp+                                                                                                                                                                                #)+                                                                                                                                                                       in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp+                                                                                                                                                else+                                                                                                                                                  let _ = "checkHorizon.newCheck.fail"+                                                                                                                                                   in let failExp =+                                                                                                                                                            Data.Set.Internal.Bin+                                                                                                                                                              1+                                                                                                                                                              ( Symantic.Parser.Grammar.Combinators.SomeFailure+                                                                                                                                                                  ( case inputToken of+                                                                                                                                                                      (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureHorizon @tok' 4+                                                                                                                                                                  )+                                                                                                                                                              )+                                                                                                                                                              Data.Set.Internal.Tip+                                                                                                                                                              Data.Set.Internal.Tip+                                                                                                                                                       in let (#+                                                                                                                                                                farInp,+                                                                                                                                                                farExp+                                                                                                                                                                #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp inp of+                                                                                                                                                                  GHC.Types.LT ->+                                                                                                                                                                    (#+                                                                                                                                                                      inp,+                                                                                                                                                                      failExp+                                                                                                                                                                    #)+                                                                                                                                                                  GHC.Types.EQ ->+                                                                                                                                                                    (#+                                                                                                                                                                      farInp,+                                                                                                                                                                      failExp GHC.Base.<> farExp+                                                                                                                                                                    #)+                                                                                                                                                                  GHC.Types.GT ->+                                                                                                                                                                    (#+                                                                                                                                                                      farInp,+                                                                                                                                                                      farExp+                                                                                                                                                                    #)+                                                                                                                                                           in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp+                                                                                                            else+                                                                                                              let _ = "choicesBranch.else"+                                                                                                               in finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp farInp farExp+                                                                                   in let _ = "catch ExceptionFailure checkedHorizon=0"+                                                                                       in let onException =+                                                                                                let _ = "onException"+                                                                                                 in \(!_exn) (!failInp) (!farInp) (!farExp) ->+                                                                                                      let _ = "loadInput checkedHorizon=0"+                                                                                                       in let _ = "checkHorizon.noCheck"+                                                                                                           in onException Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp farInp farExp+                                                                                           in let _ = "pushValue"+                                                                                               in let _ = "comment: satisfy ((GHC.Classes.==) 'd')"+                                                                                                   in let inp = failInp+                                                                                                       in let readFail = onException+                                                                                                           in let _ = "checkHorizon.newCheck: checkedHorizon=0 minHoriz=2"+                                                                                                               in if readMore (Symantic.Parser.Machine.Input.shiftRightText 1 inp)+                                                                                                                    then+                                                                                                                      let _ = "checkToken"+                                                                                                                       in let !(#+                                                                                                                                 c,+                                                                                                                                 cs+                                                                                                                                 #) = readNext inp+                                                                                                                           in if (GHC.Classes.==) 'd' c+                                                                                                                                then+                                                                                                                                  let _ = "lift2Value checkedHorizon=2"+                                                                                                                                   in let _ = "comment: satisfy ((GHC.Classes.==) 'e')"+                                                                                                                                       in let _ = "checkHorizon.oldCheck: checkedHorizon=2"+                                                                                                                                           in let _ = "checkToken"+                                                                                                                                               in let !(#+                                                                                                                                                         c,+                                                                                                                                                         cs+                                                                                                                                                         #) = readNext cs+                                                                                                                                                   in if (GHC.Classes.==) 'e' c+                                                                                                                                                        then+                                                                                                                                                          let _ = "lift2Value checkedHorizon=1"+                                                                                                                                                           in let _ = "commit"+                                                                                                                                                               in let _ = "commit"+                                                                                                                                                                   in let _ = "resume"+                                                                                                                                                                       in join+                                                                                                                                                                            farInp+                                                                                                                                                                            farExp+                                                                                                                                                                            ( let _ = "resume.genCode"+                                                                                                                                                                               in (GHC.Types.:) 'd' ((GHC.Types.:) 'e' GHC.Types . [])+                                                                                                                                                                            )+                                                                                                                                                                            cs+                                                                                                                                                        else+                                                                                                                                                          let _ = "checkToken.fail"+                                                                                                                                                           in let failExp =+                                                                                                                                                                    Data.Set.Internal.Bin+                                                                                                                                                                      1+                                                                                                                                                                      ( Symantic.Parser.Grammar.Combinators.SomeFailure+                                                                                                                                                                          ( case inputToken of+                                                                                                                                                                              (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken 'e'+                                                                                                                                                                          )+                                                                                                                                                                      )+                                                                                                                                                                      Data.Set.Internal.Tip+                                                                                                                                                                      Data.Set.Internal.Tip+                                                                                                                                                               in let (#+                                                                                                                                                                        farInp,+                                                                                                                                                                        farExp+                                                                                                                                                                        #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp cs of+                                                                                                                                                                          GHC.Types.LT ->+                                                                                                                                                                            (#+                                                                                                                                                                              cs,+                                                                                                                                                                              failExp+                                                                                                                                                                            #)+                                                                                                                                                                          GHC.Types.EQ ->+                                                                                                                                                                            (#+                                                                                                                                                                              farInp,+                                                                                                                                                                              failExp GHC.Base.<> farExp+                                                                                                                                                                            #)+                                                                                                                                                                          GHC.Types.GT ->+                                                                                                                                                                            (#+                                                                                                                                                                              farInp,+                                                                                                                                                                              farExp+                                                                                                                                                                            #)+                                                                                                                                                                   in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure cs farInp farExp+                                                                                                                                else+                                                                                                                                  let _ = "checkToken.fail"+                                                                                                                                   in let failExp =+                                                                                                                                            Data.Set.Internal.Bin+                                                                                                                                              1+                                                                                                                                              ( Symantic.Parser.Grammar.Combinators.SomeFailure+                                                                                                                                                  ( case inputToken of+                                                                                                                                                      (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken 'd'+                                                                                                                                                  )+                                                                                                                                              )+                                                                                                                                              Data.Set.Internal.Tip+                                                                                                                                              Data.Set.Internal.Tip+                                                                                                                                       in let (#+                                                                                                                                                farInp,+                                                                                                                                                farExp+                                                                                                                                                #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp inp of+                                                                                                                                                  GHC.Types.LT ->+                                                                                                                                                    (#+                                                                                                                                                      inp,+                                                                                                                                                      failExp+                                                                                                                                                    #)+                                                                                                                                                  GHC.Types.EQ ->+                                                                                                                                                    (#+                                                                                                                                                      farInp,+                                                                                                                                                      failExp GHC.Base.<> farExp+                                                                                                                                                    #)+                                                                                                                                                  GHC.Types.GT ->+                                                                                                                                                    (#+                                                                                                                                                      farInp,+                                                                                                                                                      farExp+                                                                                                                                                    #)+                                                                                                                                           in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp+                                                                                                                    else+                                                                                                                      let _ = "checkHorizon.newCheck.fail"+                                                                                                                       in let failExp =+                                                                                                                                Data.Set.Internal.Bin+                                                                                                                                  1+                                                                                                                                  ( Symantic.Parser.Grammar.Combinators.SomeFailure+                                                                                                                                      ( case inputToken of+                                                                                                                                          (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureHorizon @tok' 2+                                                                                                                                      )+                                                                                                                                  )+                                                                                                                                  Data.Set.Internal.Tip+                                                                                                                                  Data.Set.Internal.Tip+                                                                                                                           in let (#+                                                                                                                                    farInp,+                                                                                                                                    farExp+                                                                                                                                    #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp inp of+                                                                                                                                      GHC.Types.LT ->+                                                                                                                                        (#+                                                                                                                                          inp,+                                                                                                                                          failExp+                                                                                                                                        #)+                                                                                                                                      GHC.Types.EQ ->+                                                                                                                                        (#+                                                                                                                                          farInp,+                                                                                                                                          failExp GHC.Base.<> farExp+                                                                                                                                        #)+                                                                                                                                      GHC.Types.GT ->+                                                                                                                                        (#+                                                                                                                                          farInp,+                                                                                                                                          farExp+                                                                                                                                        #)+                                                                                                                               in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp+                                                                        else+                                                                          let _ = "choicesBranch.else"+                                                                           in finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp farInp farExp+                                               in let _ = "catch ExceptionFailure checkedHorizon=2"+                                                   in let onException =+                                                            let _ = "onException"+                                                             in \(!_exn) (!failInp) (!farInp) (!farExp) ->+                                                                  let _ = "loadInput checkedHorizon=2"+                                                                   in let _ = "checkHorizon.oldCheck: checkedHorizon=2"+                                                                       in onException Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp+                                                       in let _ = "pushValue"+                                                           in let _ = "comment: satisfy ((GHC.Classes.==) 'a')"+                                                               in let _ = "checkHorizon.oldCheck: checkedHorizon=2"+                                                                   in let _ = "checkToken"+                                                                       in let !(#+                                                                                 c,+                                                                                 cs+                                                                                 #) = readNext inp+                                                                           in if (GHC.Classes.==) 'a' c+                                                                                then+                                                                                  let _ = "lift2Value checkedHorizon=1"+                                                                                   in let _ = "comment: satisfy ((GHC.Classes.==) 'b')"+                                                                                       in let _ = "checkHorizon.oldCheck: checkedHorizon=1"+                                                                                           in let _ = "checkToken"+                                                                                               in let !(#+                                                                                                         c,+                                                                                                         cs+                                                                                                         #) = readNext cs+                                                                                                   in if (GHC.Classes.==) 'b' c+                                                                                                        then+                                                                                                          let _ = "lift2Value checkedHorizon=0"+                                                                                                           in let _ = "comment: satisfy ((GHC.Classes.==) 'c')"+                                                                                                               in let inp = cs+                                                                                                                   in let readFail = onException+                                                                                                                       in let _ = "checkHorizon.newCheck: checkedHorizon=0 minHoriz=1"+                                                                                                                           in if readMore inp+                                                                                                                                then+                                                                                                                                  let _ = "checkToken"+                                                                                                                                   in let !(#+                                                                                                                                             c,+                                                                                                                                             cs+                                                                                                                                             #) = readNext inp+                                                                                                                                       in if (GHC.Classes.==) 'c' c+                                                                                                                                            then+                                                                                                                                              let _ = "lift2Value checkedHorizon=1"+                                                                                                                                               in let _ = "commit"+                                                                                                                                                   in let _ = "commit"+                                                                                                                                                       in let _ = "resume"+                                                                                                                                                           in join+                                                                                                                                                                init+                                                                                                                                                                Data.Set.Internal.empty+                                                                                                                                                                ( let _ = "resume.genCode"+                                                                                                                                                                   in (GHC.Types.:) 'a' ((GHC.Types.:) 'b' ((GHC.Types.:) 'c' GHC.Types . []))+                                                                                                                                                                )+                                                                                                                                                                cs+                                                                                                                                            else+                                                                                                                                              let _ = "checkToken.fail"+                                                                                                                                               in let failExp =+                                                                                                                                                        Data.Set.Internal.Bin+                                                                                                                                                          1+                                                                                                                                                          ( Symantic.Parser.Grammar.Combinators.SomeFailure+                                                                                                                                                              ( case inputToken of+                                                                                                                                                                  (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken 'c'+                                                                                                                                                              )+                                                                                                                                                          )+                                                                                                                                                          Data.Set.Internal.Tip+                                                                                                                                                          Data.Set.Internal.Tip+                                                                                                                                                   in let (#+                                                                                                                                                            farInp,+                                                                                                                                                            farExp+                                                                                                                                                            #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init inp of+                                                                                                                                                              GHC.Types.LT ->+                                                                                                                                                                (#+                                                                                                                                                                  inp,+                                                                                                                                                                  failExp+                                                                                                                                                                #)+                                                                                                                                                              GHC.Types.EQ ->+                                                                                                                                                                (#+                                                                                                                                                                  init,+                                                                                                                                                                  failExp GHC.Base.<> Data.Set.Internal.empty+                                                                                                                                                                #)+                                                                                                                                                              GHC.Types.GT ->+                                                                                                                                                                (#+                                                                                                                                                                  init,+                                                                                                                                                                  Data.Set.Internal.empty+                                                                                                                                                                #)+                                                                                                                                                       in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp+                                                                                                                                else+                                                                                                                                  let _ = "checkHorizon.newCheck.fail"+                                                                                                                                   in let failExp =+                                                                                                                                            Data.Set.Internal.Bin+                                                                                                                                              1+                                                                                                                                              ( Symantic.Parser.Grammar.Combinators.SomeFailure+                                                                                                                                                  ( case inputToken of+                                                                                                                                                      (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureHorizon @tok' 1+                                                                                                                                                  )+                                                                                                                                              )+                                                                                                                                              Data.Set.Internal.Tip+                                                                                                                                              Data.Set.Internal.Tip+                                                                                                                                       in let (#+                                                                                                                                                farInp,+                                                                                                                                                farExp+                                                                                                                                                #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init inp of+                                                                                                                                                  GHC.Types.LT ->+                                                                                                                                                    (#+                                                                                                                                                      inp,+                                                                                                                                                      failExp+                                                                                                                                                    #)+                                                                                                                                                  GHC.Types.EQ ->+                                                                                                                                                    (#+                                                                                                                                                      init,+                                                                                                                                                      failExp GHC.Base.<> Data.Set.Internal.empty+                                                                                                                                                    #)+                                                                                                                                                  GHC.Types.GT ->+                                                                                                                                                    (#+                                                                                                                                                      init,+                                                                                                                                                      Data.Set.Internal.empty+                                                                                                                                                    #)+                                                                                                                                           in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp+                                                                                                        else+                                                                                                          let _ = "checkToken.fail"+                                                                                                           in let failExp =+                                                                                                                    Data.Set.Internal.Bin+                                                                                                                      1+                                                                                                                      ( Symantic.Parser.Grammar.Combinators.SomeFailure+                                                                                                                          ( case inputToken of+                                                                                                                              (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken 'b'+                                                                                                                          )+                                                                                                                      )+                                                                                                                      Data.Set.Internal.Tip+                                                                                                                      Data.Set.Internal.Tip+                                                                                                               in let (#+                                                                                                                        farInp,+                                                                                                                        farExp+                                                                                                                        #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init cs of+                                                                                                                          GHC.Types.LT ->+                                                                                                                            (#+                                                                                                                              cs,+                                                                                                                              failExp+                                                                                                                            #)+                                                                                                                          GHC.Types.EQ ->+                                                                                                                            (#+                                                                                                                              init,+                                                                                                                              failExp GHC.Base.<> Data.Set.Internal.empty+                                                                                                                            #)+                                                                                                                          GHC.Types.GT ->+                                                                                                                            (#+                                                                                                                              init,+                                                                                                                              Data.Set.Internal.empty+                                                                                                                            #)+                                                                                                                   in onException Symantic.Parser.Grammar.Combinators.ExceptionFailure cs farInp farExp+                                                                                else+                                                                                  let _ = "checkToken.fail"+                                                                                   in let failExp =+                                                                                            Data.Set.Internal.Bin+                                                                                              1+                                                                                              ( Symantic.Parser.Grammar.Combinators.SomeFailure+                                                                                                  ( case inputToken of+                                                                                                      (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken 'a'+                                                                                                  )+                                                                                              )+                                                                                              Data.Set.Internal.Tip+                                                                                              Data.Set.Internal.Tip+                                                                                       in let (#+                                                                                                farInp,+                                                                                                farExp+                                                                                                #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init inp of+                                                                                                  GHC.Types.LT ->+                                                                                                    (#+                                                                                                      inp,+                                                                                                      failExp+                                                                                                    #)+                                                                                                  GHC.Types.EQ ->+                                                                                                    (#+                                                                                                      init,+                                                                                                      failExp GHC.Base.<> Data.Set.Internal.empty+                                                                                                    #)+                                                                                                  GHC.Types.GT ->+                                                                                                    (#+                                                                                                      init,+                                                                                                      Data.Set.Internal.empty+                                                                                                    #)+                                                                                           in onException Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp+                            else+                              let _ = "checkHorizon.newCheck.fail"+                               in let failExp =+                                        Data.Set.Internal.Bin+                                          1+                                          ( Symantic.Parser.Grammar.Combinators.SomeFailure+                                              ( case inputToken of+                                                  (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureHorizon @tok' 2+                                              )+                                          )+                                          Data.Set.Internal.Tip+                                          Data.Set.Internal.Tip+                                   in let (#+                                            farInp,+                                            farExp+                                            #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init inp of+                                              GHC.Types.LT ->+                                                (#+                                                  inp,+                                                  failExp+                                                #)+                                              GHC.Types.EQ ->+                                                (#+                                                  init,+                                                  failExp GHC.Base.<> Data.Set.Internal.empty+                                                #)+                                              GHC.Types.GT ->+                                                (#+                                                  init,+                                                  Data.Set.Internal.empty+                                                #)+                                       in finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp+        )
+ tests/Golden/Splice/G2.expected.txt view
@@ -0,0 +1,271 @@+\(input :: inp) ->+  let !(#+         init,+         readMore,+         readNext+         #) =+          let _ = "cursorOf"+           in let next+                    ( t@( Data.Text.Internal.Text+                            arr+                            off+                            unconsumed+                          )+                      ) =+                      let !( Data.Text.Unsafe.Iter+                               c+                               d+                             ) = Data.Text.Unsafe.iter t 0+                       in (#+                            c,+                            Data.Text.Internal.Text arr (off GHC.Num.+ d) (unconsumed GHC.Num.- d)+                          #)+                  more+                    ( Data.Text.Internal.Text+                        _+                        _+                        unconsumed+                      ) = unconsumed GHC.Classes.> 0+               in (# input, more, next #)+      finalRet = \_farInp _farExp v _inp -> Symantic.Parser.Machine.Generate.returnST GHC.Base.$ Data.Either.Right v+      finalRaise ::+        forall st b.+        Symantic.Parser.Machine.Generate.OnException+          st+          inp+          b = \(!exn) _failInp (!farInp) (!farExp) ->+          Symantic.Parser.Machine.Generate.returnST GHC.Base.$+            Data.Either.Left+              Symantic.Parser.Machine.Generate.ParsingError+                { Symantic.Parser.Machine.Generate.parsingErrorOffset = Symantic.Parser.Machine.Input.offset farInp,+                  Symantic.Parser.Machine.Generate.parsingErrorException = exn,+                  Symantic.Parser.Machine.Generate.parsingErrorUnexpected =+                    if readMore farInp+                      then+                        GHC.Maybe.Just+                          ( let (#+                                  c,+                                  _+                                  #) = readNext farInp+                             in c+                          )+                      else GHC.Maybe.Nothing,+                  Symantic.Parser.Machine.Generate.parsingErrorExpecting =+                    let ( minHoriz,+                          res+                          ) =+                            Data.Set.Internal.foldr+                              ( \f+                                 ( minH,+                                   acc+                                   ) -> case Symantic.Parser.Grammar.Combinators.unSomeFailure f of+                                    GHC.Maybe.Just (Symantic.Parser.Grammar.Combinators.FailureHorizon h :: Symantic.Parser.Grammar.Combinators.Failure (Symantic.Parser.Grammar.Combinators.CombSatisfiable (Symantic.Parser.Machine.Input.InputToken inp)))+                                      | GHC.Maybe.Just old <- minH ->+                                        ( GHC.Maybe.Just (GHC.Classes.min old h),+                                          acc+                                        )+                                      | GHC.Base.otherwise ->+                                        ( GHC.Maybe.Just h,+                                          acc+                                        )+                                    _ ->+                                      ( minH,+                                        f GHC.Types.: acc+                                      )+                              )+                              ( GHC.Maybe.Nothing,+                                GHC.Types . []+                              )+                              farExp+                     in Data.Set.Internal.fromList GHC.Base.$+                          ( case minHoriz of+                              GHC.Maybe.Just h -> Symantic.Parser.Grammar.Combinators.SomeFailure (Symantic.Parser.Grammar.Combinators.FailureHorizon @(Symantic.Parser.Machine.Input.InputToken inp) h) GHC.Types.: res+                              GHC.Maybe.Nothing -> res+                          )+                }+   in GHC.ST.runST+        ( let inputToken = Data.Proxy.Proxy :: Data.Proxy.Proxy (Symantic.Parser.Machine.Input.InputToken inp)+           in let inp = init+               in let readFail = finalRaise+                   in let _ = "checkHorizon.newCheck: checkedHorizon=0 minHoriz=3"+                       in if readMore (Symantic.Parser.Machine.Input.shiftRightText 2 inp)+                            then+                              let+                               in let _ = "pushValue"+                                   in let _ = "catch ExceptionFailure checkedHorizon=3"+                                       in let onException =+                                                let _ = "onException"+                                                 in \(!_exn) (!failInp) (!farInp) (!farExp) ->+                                                      let _ = "loadInput checkedHorizon=3"+                                                       in let _ = "checkHorizon.oldCheck: checkedHorizon=3"+                                                           in finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp+                                           in let _ = "pushValue"+                                               in let _ = "comment: satisfy ((GHC.Classes.==) 'a')"+                                                   in let _ = "checkHorizon.oldCheck: checkedHorizon=3"+                                                       in let _ = "checkToken"+                                                           in let !(#+                                                                     c,+                                                                     cs+                                                                     #) = readNext inp+                                                               in if (GHC.Classes.==) 'a' c+                                                                    then+                                                                      let _ = "lift2Value checkedHorizon=2"+                                                                       in let _ = "comment: satisfy ((GHC.Classes.==) 'b')"+                                                                           in let _ = "checkHorizon.oldCheck: checkedHorizon=2"+                                                                               in let _ = "checkToken"+                                                                                   in let !(#+                                                                                             c,+                                                                                             cs+                                                                                             #) = readNext cs+                                                                                       in if (GHC.Classes.==) 'b' c+                                                                                            then+                                                                                              let _ = "lift2Value checkedHorizon=1"+                                                                                               in let _ = "comment: satisfy ((GHC.Classes.==) 'c')"+                                                                                                   in let _ = "checkHorizon.oldCheck: checkedHorizon=1"+                                                                                                       in let _ = "checkToken"+                                                                                                           in let !(#+                                                                                                                     c,+                                                                                                                     cs+                                                                                                                     #) = readNext cs+                                                                                                               in if (GHC.Classes.==) 'c' c+                                                                                                                    then+                                                                                                                      let _ = "lift2Value checkedHorizon=0"+                                                                                                                       in let _ = "commit"+                                                                                                                           in let _ = "lift2Value checkedHorizon=0"+                                                                                                                               in let _ = "resume"+                                                                                                                                   in finalRet+                                                                                                                                        init+                                                                                                                                        Data.Set.Internal.empty+                                                                                                                                        ( let _ = "resume.genCode"+                                                                                                                                           in GHC.Show.show ((GHC.Types.:) 'a' ((GHC.Types.:) 'b' ((GHC.Types.:) 'c' GHC.Types . [])))+                                                                                                                                        )+                                                                                                                                        cs+                                                                                                                    else+                                                                                                                      let _ = "checkToken.fail"+                                                                                                                       in let failExp =+                                                                                                                                Data.Set.Internal.Bin+                                                                                                                                  1+                                                                                                                                  ( Symantic.Parser.Grammar.Combinators.SomeFailure+                                                                                                                                      ( case inputToken of+                                                                                                                                          (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken 'c'+                                                                                                                                      )+                                                                                                                                  )+                                                                                                                                  Data.Set.Internal.Tip+                                                                                                                                  Data.Set.Internal.Tip+                                                                                                                           in let (#+                                                                                                                                    farInp,+                                                                                                                                    farExp+                                                                                                                                    #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init cs of+                                                                                                                                      GHC.Types.LT ->+                                                                                                                                        (#+                                                                                                                                          cs,+                                                                                                                                          failExp+                                                                                                                                        #)+                                                                                                                                      GHC.Types.EQ ->+                                                                                                                                        (#+                                                                                                                                          init,+                                                                                                                                          failExp GHC.Base.<> Data.Set.Internal.empty+                                                                                                                                        #)+                                                                                                                                      GHC.Types.GT ->+                                                                                                                                        (#+                                                                                                                                          init,+                                                                                                                                          Data.Set.Internal.empty+                                                                                                                                        #)+                                                                                                                               in onException Symantic.Parser.Grammar.Combinators.ExceptionFailure cs farInp farExp+                                                                                            else+                                                                                              let _ = "checkToken.fail"+                                                                                               in let failExp =+                                                                                                        Data.Set.Internal.Bin+                                                                                                          1+                                                                                                          ( Symantic.Parser.Grammar.Combinators.SomeFailure+                                                                                                              ( case inputToken of+                                                                                                                  (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken 'b'+                                                                                                              )+                                                                                                          )+                                                                                                          Data.Set.Internal.Tip+                                                                                                          Data.Set.Internal.Tip+                                                                                                   in let (#+                                                                                                            farInp,+                                                                                                            farExp+                                                                                                            #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init cs of+                                                                                                              GHC.Types.LT ->+                                                                                                                (#+                                                                                                                  cs,+                                                                                                                  failExp+                                                                                                                #)+                                                                                                              GHC.Types.EQ ->+                                                                                                                (#+                                                                                                                  init,+                                                                                                                  failExp GHC.Base.<> Data.Set.Internal.empty+                                                                                                                #)+                                                                                                              GHC.Types.GT ->+                                                                                                                (#+                                                                                                                  init,+                                                                                                                  Data.Set.Internal.empty+                                                                                                                #)+                                                                                                       in onException Symantic.Parser.Grammar.Combinators.ExceptionFailure cs farInp farExp+                                                                    else+                                                                      let _ = "checkToken.fail"+                                                                       in let failExp =+                                                                                Data.Set.Internal.Bin+                                                                                  1+                                                                                  ( Symantic.Parser.Grammar.Combinators.SomeFailure+                                                                                      ( case inputToken of+                                                                                          (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken 'a'+                                                                                      )+                                                                                  )+                                                                                  Data.Set.Internal.Tip+                                                                                  Data.Set.Internal.Tip+                                                                           in let (#+                                                                                    farInp,+                                                                                    farExp+                                                                                    #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init inp of+                                                                                      GHC.Types.LT ->+                                                                                        (#+                                                                                          inp,+                                                                                          failExp+                                                                                        #)+                                                                                      GHC.Types.EQ ->+                                                                                        (#+                                                                                          init,+                                                                                          failExp GHC.Base.<> Data.Set.Internal.empty+                                                                                        #)+                                                                                      GHC.Types.GT ->+                                                                                        (#+                                                                                          init,+                                                                                          Data.Set.Internal.empty+                                                                                        #)+                                                                               in onException Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp+                            else+                              let _ = "checkHorizon.newCheck.fail"+                               in let failExp =+                                        Data.Set.Internal.Bin+                                          1+                                          ( Symantic.Parser.Grammar.Combinators.SomeFailure+                                              ( case inputToken of+                                                  (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureHorizon @tok' 3+                                              )+                                          )+                                          Data.Set.Internal.Tip+                                          Data.Set.Internal.Tip+                                   in let (#+                                            farInp,+                                            farExp+                                            #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init inp of+                                              GHC.Types.LT ->+                                                (#+                                                  inp,+                                                  failExp+                                                #)+                                              GHC.Types.EQ ->+                                                (#+                                                  init,+                                                  failExp GHC.Base.<> Data.Set.Internal.empty+                                                #)+                                              GHC.Types.GT ->+                                                (#+                                                  init,+                                                  Data.Set.Internal.empty+                                                #)+                                       in finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp+        )
+ tests/Golden/Splice/G20.expected.txt view
@@ -0,0 +1,321 @@+\(input :: inp) ->+  let !(#+         init,+         readMore,+         readNext+         #) =+          let _ = "cursorOf"+           in let next+                    ( t@( Data.Text.Internal.Text+                            arr+                            off+                            unconsumed+                          )+                      ) =+                      let !( Data.Text.Unsafe.Iter+                               c+                               d+                             ) = Data.Text.Unsafe.iter t 0+                       in (#+                            c,+                            Data.Text.Internal.Text arr (off GHC.Num.+ d) (unconsumed GHC.Num.- d)+                          #)+                  more+                    ( Data.Text.Internal.Text+                        _+                        _+                        unconsumed+                      ) = unconsumed GHC.Classes.> 0+               in (# input, more, next #)+      finalRet = \_farInp _farExp v _inp -> Symantic.Parser.Machine.Generate.returnST GHC.Base.$ Data.Either.Right v+      finalRaise ::+        forall st b.+        Symantic.Parser.Machine.Generate.OnException+          st+          inp+          b = \(!exn) _failInp (!farInp) (!farExp) ->+          Symantic.Parser.Machine.Generate.returnST GHC.Base.$+            Data.Either.Left+              Symantic.Parser.Machine.Generate.ParsingError+                { Symantic.Parser.Machine.Generate.parsingErrorOffset = Symantic.Parser.Machine.Input.offset farInp,+                  Symantic.Parser.Machine.Generate.parsingErrorException = exn,+                  Symantic.Parser.Machine.Generate.parsingErrorUnexpected =+                    if readMore farInp+                      then+                        GHC.Maybe.Just+                          ( let (#+                                  c,+                                  _+                                  #) = readNext farInp+                             in c+                          )+                      else GHC.Maybe.Nothing,+                  Symantic.Parser.Machine.Generate.parsingErrorExpecting =+                    let ( minHoriz,+                          res+                          ) =+                            Data.Set.Internal.foldr+                              ( \f+                                 ( minH,+                                   acc+                                   ) -> case Symantic.Parser.Grammar.Combinators.unSomeFailure f of+                                    GHC.Maybe.Just (Symantic.Parser.Grammar.Combinators.FailureHorizon h :: Symantic.Parser.Grammar.Combinators.Failure (Symantic.Parser.Grammar.Combinators.CombSatisfiable (Symantic.Parser.Machine.Input.InputToken inp)))+                                      | GHC.Maybe.Just old <- minH ->+                                        ( GHC.Maybe.Just (GHC.Classes.min old h),+                                          acc+                                        )+                                      | GHC.Base.otherwise ->+                                        ( GHC.Maybe.Just h,+                                          acc+                                        )+                                    _ ->+                                      ( minH,+                                        f GHC.Types.: acc+                                      )+                              )+                              ( GHC.Maybe.Nothing,+                                GHC.Types . []+                              )+                              farExp+                     in Data.Set.Internal.fromList GHC.Base.$+                          ( case minHoriz of+                              GHC.Maybe.Just h -> Symantic.Parser.Grammar.Combinators.SomeFailure (Symantic.Parser.Grammar.Combinators.FailureHorizon @(Symantic.Parser.Machine.Input.InputToken inp) h) GHC.Types.: res+                              GHC.Maybe.Nothing -> res+                          )+                }+   in GHC.ST.runST+        ( let inputToken = Data.Proxy.Proxy :: Data.Proxy.Proxy (Symantic.Parser.Machine.Input.InputToken inp)+           in let inp = init+               in let readFail = finalRaise+                   in let _ = "checkHorizon.newCheck: checkedHorizon=0 minHoriz=3"+                       in if readMore (Symantic.Parser.Machine.Input.shiftRightText 2 inp)+                            then+                              let+                               in let _ = "pushValue"+                                   in let join = \farInp farExp v (!inp) ->+                                            let _ = "lift2Value checkedHorizon=0"+                                             in let _ = "catch ExceptionFailure checkedHorizon=0"+                                                 in let onException =+                                                          let _ = "onException"+                                                           in \(!_exn) (!failInp) (!farInp) (!farExp) ->+                                                                let _ = "loadInput checkedHorizon=0"+                                                                 in let _ = "checkHorizon.noCheck"+                                                                     in finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp+                                                     in let _ = "pushValue"+                                                         in let _ = "comment: satisfy ((GHC.Classes.==) 'd')"+                                                             in let inp = inp+                                                                 in let readFail = onException+                                                                     in let _ = "checkHorizon.newCheck: checkedHorizon=0 minHoriz=3"+                                                                         in if readMore (Symantic.Parser.Machine.Input.shiftRightText 2 inp)+                                                                              then+                                                                                let _ = "checkToken"+                                                                                 in let !(#+                                                                                           c,+                                                                                           cs+                                                                                           #) = readNext inp+                                                                                     in if (GHC.Classes.==) 'd' c+                                                                                          then+                                                                                            let _ = "lift2Value checkedHorizon=3"+                                                                                             in let _ = "comment: satisfy ((GHC.Classes.==) 'e')"+                                                                                                 in let _ = "checkHorizon.oldCheck: checkedHorizon=3"+                                                                                                     in let _ = "checkToken"+                                                                                                         in let !(#+                                                                                                                   c,+                                                                                                                   cs+                                                                                                                   #) = readNext cs+                                                                                                             in if (GHC.Classes.==) 'e' c+                                                                                                                  then+                                                                                                                    let _ = "lift2Value checkedHorizon=2"+                                                                                                                     in let _ = "comment: satisfy ((GHC.Classes.==) 'f')"+                                                                                                                         in let _ = "checkHorizon.oldCheck: checkedHorizon=2"+                                                                                                                             in let _ = "checkToken"+                                                                                                                                 in let !(#+                                                                                                                                           c,+                                                                                                                                           cs+                                                                                                                                           #) = readNext cs+                                                                                                                                     in if (GHC.Classes.==) 'f' c+                                                                                                                                          then+                                                                                                                                            let _ = "lift2Value checkedHorizon=1"+                                                                                                                                             in let _ = "commit"+                                                                                                                                                 in let _ = "lift2Value checkedHorizon=1"+                                                                                                                                                     in let _ = "resume"+                                                                                                                                                         in finalRet+                                                                                                                                                              farInp+                                                                                                                                                              farExp+                                                                                                                                                              ( let _ = "resume.genCode"+                                                                                                                                                                 in GHC.Show.show GHC.Tuple . ()+                                                                                                                                                              )+                                                                                                                                                              cs+                                                                                                                                          else+                                                                                                                                            let _ = "checkToken.fail"+                                                                                                                                             in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure cs farInp farExp+                                                                                                                  else+                                                                                                                    let _ = "checkToken.fail"+                                                                                                                     in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure cs farInp farExp+                                                                                          else+                                                                                            let _ = "checkToken.fail"+                                                                                             in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp+                                                                              else+                                                                                let _ = "checkHorizon.newCheck.fail"+                                                                                 in let failExp =+                                                                                          Data.Set.Internal.Bin+                                                                                            1+                                                                                            ( Symantic.Parser.Grammar.Combinators.SomeFailure+                                                                                                ( case inputToken of+                                                                                                    (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureHorizon @tok' 3+                                                                                                )+                                                                                            )+                                                                                            Data.Set.Internal.Tip+                                                                                            Data.Set.Internal.Tip+                                                                                     in let (#+                                                                                              farInp,+                                                                                              farExp+                                                                                              #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp inp of+                                                                                                GHC.Types.LT ->+                                                                                                  (#+                                                                                                    inp,+                                                                                                    failExp+                                                                                                  #)+                                                                                                GHC.Types.EQ ->+                                                                                                  (#+                                                                                                    farInp,+                                                                                                    failExp GHC.Base.<> farExp+                                                                                                  #)+                                                                                                GHC.Types.GT ->+                                                                                                  (#+                                                                                                    farInp,+                                                                                                    farExp+                                                                                                  #)+                                                                                         in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp+                                       in let _ = "catch ExceptionFailure checkedHorizon=3"+                                           in let onException =+                                                    let _ = "onException"+                                                     in \(!_exn) (!failInp) (!farInp) (!farExp) ->+                                                          let _ = "comment: raiseAgainIfConsumed"+                                                           in let _ = "saveInput checkedHorizon=0"+                                                               in let _ = "lift2Value checkedHorizon=0"+                                                                   in if ( \( Data.Text.Internal.Text+                                                                                _+                                                                                i+                                                                                _+                                                                              )+                                                                            ( Data.Text.Internal.Text+                                                                                _+                                                                                j+                                                                                _+                                                                              ) -> i GHC.Classes.== j+                                                                         )+                                                                        inp+                                                                        failInp+                                                                        then+                                                                          let _ = "choicesBranch checkedHorizon=0"+                                                                           in let _ = "catch ExceptionFailure checkedHorizon=0"+                                                                               in let onException =+                                                                                        let _ = "onException"+                                                                                         in \(!_exn) (!failInp) (!farInp) (!farExp) ->+                                                                                              let _ = "loadInput checkedHorizon=0"+                                                                                               in let _ = "checkHorizon.noCheck"+                                                                                                   in finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp farInp farExp+                                                                                   in let _ = "pushValue"+                                                                                       in let _ = "commit"+                                                                                           in let _ = "resume"+                                                                                               in join+                                                                                                    farInp+                                                                                                    farExp+                                                                                                    ( let _ = "resume.genCode"+                                                                                                       in GHC.Types . []+                                                                                                    )+                                                                                                    failInp+                                                                        else+                                                                          let _ = "choicesBranch.else"+                                                                           in finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp farInp farExp+                                               in let _ = "catch ExceptionFailure checkedHorizon=3"+                                                   in let onException =+                                                            let _ = "onException"+                                                             in \(!_exn) (!failInp) (!farInp) (!farExp) ->+                                                                  let _ = "loadInput checkedHorizon=3"+                                                                   in let _ = "checkHorizon.oldCheck: checkedHorizon=3"+                                                                       in onException Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp+                                                       in let _ = "pushValue"+                                                           in let _ = "comment: satisfy ((GHC.Classes.==) 'a')"+                                                               in let _ = "checkHorizon.oldCheck: checkedHorizon=3"+                                                                   in let _ = "checkToken"+                                                                       in let !(#+                                                                                 c,+                                                                                 cs+                                                                                 #) = readNext inp+                                                                           in if (GHC.Classes.==) 'a' c+                                                                                then+                                                                                  let _ = "lift2Value checkedHorizon=2"+                                                                                   in let _ = "comment: satisfy ((GHC.Classes.==) 'b')"+                                                                                       in let _ = "checkHorizon.oldCheck: checkedHorizon=2"+                                                                                           in let _ = "checkToken"+                                                                                               in let !(#+                                                                                                         c,+                                                                                                         cs+                                                                                                         #) = readNext cs+                                                                                                   in if (GHC.Classes.==) 'b' c+                                                                                                        then+                                                                                                          let _ = "lift2Value checkedHorizon=1"+                                                                                                           in let _ = "comment: satisfy ((GHC.Classes.==) 'c')"+                                                                                                               in let _ = "checkHorizon.oldCheck: checkedHorizon=1"+                                                                                                                   in let _ = "checkToken"+                                                                                                                       in let !(#+                                                                                                                                 c,+                                                                                                                                 cs+                                                                                                                                 #) = readNext cs+                                                                                                                           in if (GHC.Classes.==) 'c' c+                                                                                                                                then+                                                                                                                                  let _ = "lift2Value checkedHorizon=0"+                                                                                                                                   in let _ = "commit"+                                                                                                                                       in let _ = "commit"+                                                                                                                                           in let _ = "resume"+                                                                                                                                               in join+                                                                                                                                                    init+                                                                                                                                                    Data.Set.Internal.empty+                                                                                                                                                    ( let _ = "resume.genCode"+                                                                                                                                                       in (GHC.Types.:) 'a' ((GHC.Types.:) 'b' ((GHC.Types.:) 'c' GHC.Types . []))+                                                                                                                                                    )+                                                                                                                                                    cs+                                                                                                                                else+                                                                                                                                  let _ = "checkToken.fail"+                                                                                                                                   in onException Symantic.Parser.Grammar.Combinators.ExceptionFailure cs init Data.Set.Internal.empty+                                                                                                        else+                                                                                                          let _ = "checkToken.fail"+                                                                                                           in onException Symantic.Parser.Grammar.Combinators.ExceptionFailure cs init Data.Set.Internal.empty+                                                                                else+                                                                                  let _ = "checkToken.fail"+                                                                                   in onException Symantic.Parser.Grammar.Combinators.ExceptionFailure inp init Data.Set.Internal.empty+                            else+                              let _ = "checkHorizon.newCheck.fail"+                               in let failExp =+                                        Data.Set.Internal.Bin+                                          1+                                          ( Symantic.Parser.Grammar.Combinators.SomeFailure+                                              ( case inputToken of+                                                  (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureHorizon @tok' 3+                                              )+                                          )+                                          Data.Set.Internal.Tip+                                          Data.Set.Internal.Tip+                                   in let (#+                                            farInp,+                                            farExp+                                            #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init inp of+                                              GHC.Types.LT ->+                                                (#+                                                  inp,+                                                  failExp+                                                #)+                                              GHC.Types.EQ ->+                                                (#+                                                  init,+                                                  failExp GHC.Base.<> Data.Set.Internal.empty+                                                #)+                                              GHC.Types.GT ->+                                                (#+                                                  init,+                                                  Data.Set.Internal.empty+                                                #)+                                       in finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp+        )
+ tests/Golden/Splice/G3.expected.txt view
@@ -0,0 +1,225 @@+\(input :: inp) ->+  let !(#+         init,+         readMore,+         readNext+         #) =+          let _ = "cursorOf"+           in let next+                    ( t@( Data.Text.Internal.Text+                            arr+                            off+                            unconsumed+                          )+                      ) =+                      let !( Data.Text.Unsafe.Iter+                               c+                               d+                             ) = Data.Text.Unsafe.iter t 0+                       in (#+                            c,+                            Data.Text.Internal.Text arr (off GHC.Num.+ d) (unconsumed GHC.Num.- d)+                          #)+                  more+                    ( Data.Text.Internal.Text+                        _+                        _+                        unconsumed+                      ) = unconsumed GHC.Classes.> 0+               in (# input, more, next #)+      finalRet = \_farInp _farExp v _inp -> Symantic.Parser.Machine.Generate.returnST GHC.Base.$ Data.Either.Right v+      finalRaise ::+        forall st b.+        Symantic.Parser.Machine.Generate.OnException+          st+          inp+          b = \(!exn) _failInp (!farInp) (!farExp) ->+          Symantic.Parser.Machine.Generate.returnST GHC.Base.$+            Data.Either.Left+              Symantic.Parser.Machine.Generate.ParsingError+                { Symantic.Parser.Machine.Generate.parsingErrorOffset = Symantic.Parser.Machine.Input.offset farInp,+                  Symantic.Parser.Machine.Generate.parsingErrorException = exn,+                  Symantic.Parser.Machine.Generate.parsingErrorUnexpected =+                    if readMore farInp+                      then+                        GHC.Maybe.Just+                          ( let (#+                                  c,+                                  _+                                  #) = readNext farInp+                             in c+                          )+                      else GHC.Maybe.Nothing,+                  Symantic.Parser.Machine.Generate.parsingErrorExpecting =+                    let ( minHoriz,+                          res+                          ) =+                            Data.Set.Internal.foldr+                              ( \f+                                 ( minH,+                                   acc+                                   ) -> case Symantic.Parser.Grammar.Combinators.unSomeFailure f of+                                    GHC.Maybe.Just (Symantic.Parser.Grammar.Combinators.FailureHorizon h :: Symantic.Parser.Grammar.Combinators.Failure (Symantic.Parser.Grammar.Combinators.CombSatisfiable (Symantic.Parser.Machine.Input.InputToken inp)))+                                      | GHC.Maybe.Just old <- minH ->+                                        ( GHC.Maybe.Just (GHC.Classes.min old h),+                                          acc+                                        )+                                      | GHC.Base.otherwise ->+                                        ( GHC.Maybe.Just h,+                                          acc+                                        )+                                    _ ->+                                      ( minH,+                                        f GHC.Types.: acc+                                      )+                              )+                              ( GHC.Maybe.Nothing,+                                GHC.Types . []+                              )+                              farExp+                     in Data.Set.Internal.fromList GHC.Base.$+                          ( case minHoriz of+                              GHC.Maybe.Just h -> Symantic.Parser.Grammar.Combinators.SomeFailure (Symantic.Parser.Grammar.Combinators.FailureHorizon @(Symantic.Parser.Machine.Input.InputToken inp) h) GHC.Types.: res+                              GHC.Maybe.Nothing -> res+                          )+                }+   in GHC.ST.runST+        ( let inputToken = Data.Proxy.Proxy :: Data.Proxy.Proxy (Symantic.Parser.Machine.Input.InputToken inp)+           in let _ = "checkHorizon.noCheck"+               in let+                   in let _ = "pushValue"+                       in let _ = "pushValue"+                           in do+                                let dupv = \x -> x+                                reg <- GHC.STRef.newSTRef dupv+                                let _ = "iter"+                                 in let onException loopInput =+                                          let _ = "onException"+                                           in \(!_exn) (!failInp) (!farInp) (!farExp) ->+                                                let _ = "comment: raiseAgainIfConsumed"+                                                 in let _ = "saveInput checkedHorizon=0"+                                                     in let _ = "lift2Value checkedHorizon=0"+                                                         in if ( \( Data.Text.Internal.Text+                                                                      _+                                                                      i+                                                                      _+                                                                    )+                                                                  ( Data.Text.Internal.Text+                                                                      _+                                                                      j+                                                                      _+                                                                    ) -> i GHC.Classes.== j+                                                               )+                                                              loopInput+                                                              failInp+                                                              then+                                                                let _ = "choicesBranch checkedHorizon=0"+                                                                 in do+                                                                      sr <- GHC.STRef.readSTRef reg+                                                                      let _ = "pushValue"+                                                                       in let _ = "lift2Value checkedHorizon=0"+                                                                           in let _ = "lift2Value checkedHorizon=0"+                                                                               in let _ = "resume"+                                                                                   in finalRet+                                                                                        farInp+                                                                                        farExp+                                                                                        ( let _ = "resume.genCode"+                                                                                           in GHC.Show.show (sr GHC.Types . [])+                                                                                        )+                                                                                        failInp+                                                              else+                                                                let _ = "choicesBranch.else"+                                                                 in finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp farInp farExp+                                        loop = \_callerOnReturn callerInput callerOnExceptionStackByLabel ->+                                          let _ = "pushValue"+                                           in let _ = "comment: satisfy ((GHC.Classes.==) 'a')"+                                               in let inp = callerInput+                                                   in let readFail = onException callerInput+                                                       in let _ = "checkHorizon.newCheck: checkedHorizon=0 minHoriz=1"+                                                           in if readMore inp+                                                                then+                                                                  let _ = "checkToken"+                                                                   in let !(#+                                                                             c,+                                                                             cs+                                                                             #) = readNext inp+                                                                       in if (GHC.Classes.==) 'a' c+                                                                            then+                                                                              let _ = "lift2Value checkedHorizon=1"+                                                                               in let _ = "pushValue"+                                                                                   in let _ = "lift2Value checkedHorizon=1"+                                                                                       in do+                                                                                            sr <- GHC.STRef.readSTRef reg+                                                                                            let _ = "lift2Value checkedHorizon=1"+                                                                                             in do+                                                                                                  let dupv = \x -> sr ((GHC.Types.:) 'a' x)+                                                                                                  GHC.STRef.writeSTRef reg dupv+                                                                                                  let _ = "jump"+                                                                                                   in loop (GHC.Err.error "invalid onReturn") cs (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure readFail Data.Map.Internal.Tip Data.Map.Internal.Tip)+                                                                            else+                                                                              let _ = "checkToken.fail"+                                                                               in let failExp =+                                                                                        Data.Set.Internal.Bin+                                                                                          1+                                                                                          ( Symantic.Parser.Grammar.Combinators.SomeFailure+                                                                                              ( case inputToken of+                                                                                                  (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken 'a'+                                                                                              )+                                                                                          )+                                                                                          Data.Set.Internal.Tip+                                                                                          Data.Set.Internal.Tip+                                                                                   in let (#+                                                                                            farInp,+                                                                                            farExp+                                                                                            #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init inp of+                                                                                              GHC.Types.LT ->+                                                                                                (#+                                                                                                  inp,+                                                                                                  failExp+                                                                                                #)+                                                                                              GHC.Types.EQ ->+                                                                                                (#+                                                                                                  init,+                                                                                                  failExp GHC.Base.<> Data.Set.Internal.empty+                                                                                                #)+                                                                                              GHC.Types.GT ->+                                                                                                (#+                                                                                                  init,+                                                                                                  Data.Set.Internal.empty+                                                                                                #)+                                                                                       in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp+                                                                else+                                                                  let _ = "checkHorizon.newCheck.fail"+                                                                   in let failExp =+                                                                            Data.Set.Internal.Bin+                                                                              1+                                                                              ( Symantic.Parser.Grammar.Combinators.SomeFailure+                                                                                  ( case inputToken of+                                                                                      (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureHorizon @tok' 1+                                                                                  )+                                                                              )+                                                                              Data.Set.Internal.Tip+                                                                              Data.Set.Internal.Tip+                                                                       in let (#+                                                                                farInp,+                                                                                farExp+                                                                                #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init inp of+                                                                                  GHC.Types.LT ->+                                                                                    (#+                                                                                      inp,+                                                                                      failExp+                                                                                    #)+                                                                                  GHC.Types.EQ ->+                                                                                    (#+                                                                                      init,+                                                                                      failExp GHC.Base.<> Data.Set.Internal.empty+                                                                                    #)+                                                                                  GHC.Types.GT ->+                                                                                    (#+                                                                                      init,+                                                                                      Data.Set.Internal.empty+                                                                                    #)+                                                                           in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp+                                     in let _ = "jump"+                                         in loop finalRet init Data.Map.Internal.Tip+        )
+ tests/Golden/Splice/G4.expected.txt view
@@ -0,0 +1,418 @@+\(input :: inp) ->+  let !(#+         init,+         readMore,+         readNext+         #) =+          let _ = "cursorOf"+           in let next+                    ( t@( Data.Text.Internal.Text+                            arr+                            off+                            unconsumed+                          )+                      ) =+                      let !( Data.Text.Unsafe.Iter+                               c+                               d+                             ) = Data.Text.Unsafe.iter t 0+                       in (#+                            c,+                            Data.Text.Internal.Text arr (off GHC.Num.+ d) (unconsumed GHC.Num.- d)+                          #)+                  more+                    ( Data.Text.Internal.Text+                        _+                        _+                        unconsumed+                      ) = unconsumed GHC.Classes.> 0+               in (# input, more, next #)+      finalRet = \_farInp _farExp v _inp -> Symantic.Parser.Machine.Generate.returnST GHC.Base.$ Data.Either.Right v+      finalRaise ::+        forall st b.+        Symantic.Parser.Machine.Generate.OnException+          st+          inp+          b = \(!exn) _failInp (!farInp) (!farExp) ->+          Symantic.Parser.Machine.Generate.returnST GHC.Base.$+            Data.Either.Left+              Symantic.Parser.Machine.Generate.ParsingError+                { Symantic.Parser.Machine.Generate.parsingErrorOffset = Symantic.Parser.Machine.Input.offset farInp,+                  Symantic.Parser.Machine.Generate.parsingErrorException = exn,+                  Symantic.Parser.Machine.Generate.parsingErrorUnexpected =+                    if readMore farInp+                      then+                        GHC.Maybe.Just+                          ( let (#+                                  c,+                                  _+                                  #) = readNext farInp+                             in c+                          )+                      else GHC.Maybe.Nothing,+                  Symantic.Parser.Machine.Generate.parsingErrorExpecting =+                    let ( minHoriz,+                          res+                          ) =+                            Data.Set.Internal.foldr+                              ( \f+                                 ( minH,+                                   acc+                                   ) -> case Symantic.Parser.Grammar.Combinators.unSomeFailure f of+                                    GHC.Maybe.Just (Symantic.Parser.Grammar.Combinators.FailureHorizon h :: Symantic.Parser.Grammar.Combinators.Failure (Symantic.Parser.Grammar.Combinators.CombSatisfiable (Symantic.Parser.Machine.Input.InputToken inp)))+                                      | GHC.Maybe.Just old <- minH ->+                                        ( GHC.Maybe.Just (GHC.Classes.min old h),+                                          acc+                                        )+                                      | GHC.Base.otherwise ->+                                        ( GHC.Maybe.Just h,+                                          acc+                                        )+                                    _ ->+                                      ( minH,+                                        f GHC.Types.: acc+                                      )+                              )+                              ( GHC.Maybe.Nothing,+                                GHC.Types . []+                              )+                              farExp+                     in Data.Set.Internal.fromList GHC.Base.$+                          ( case minHoriz of+                              GHC.Maybe.Just h -> Symantic.Parser.Grammar.Combinators.SomeFailure (Symantic.Parser.Grammar.Combinators.FailureHorizon @(Symantic.Parser.Machine.Input.InputToken inp) h) GHC.Types.: res+                              GHC.Maybe.Nothing -> res+                          )+                }+   in GHC.ST.runST+        ( let inputToken = Data.Proxy.Proxy :: Data.Proxy.Proxy (Symantic.Parser.Machine.Input.InputToken inp)+           in let inp = init+               in let readFail = finalRaise+                   in let _ = "checkHorizon.newCheck: checkedHorizon=0 minHoriz=4"+                       in if readMore (Symantic.Parser.Machine.Input.shiftRightText 3 inp)+                            then+                              let name = \(!callerOnReturn) (!callerInput) (!callerOnExceptionStackByLabel) ->+                                    let _ = "catch ExceptionFailure checkedHorizon=0"+                                     in let onException =+                                              let _ = "onException"+                                               in \(!_exn) (!failInp) (!farInp) (!farExp) ->+                                                    let _ = "loadInput checkedHorizon=0"+                                                     in let _ = "checkHorizon.noCheck"+                                                         in Data.Map.Strict.Internal.findWithDefault finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure callerOnExceptionStackByLabel Symantic.Parser.Grammar.Combinators.ExceptionFailure callerInput farInp farExp+                                         in let _ = "pushValue"+                                             in let _ = "comment: satisfy ((GHC.Classes.==) 'a')"+                                                 in let inp = callerInput+                                                     in let readFail = onException+                                                         in let _ = "checkHorizon.newCheck: checkedHorizon=0 minHoriz=4"+                                                             in if readMore (Symantic.Parser.Machine.Input.shiftRightText 3 inp)+                                                                  then+                                                                    let _ = "checkToken"+                                                                     in let !(#+                                                                               c,+                                                                               cs+                                                                               #) = readNext inp+                                                                         in if (GHC.Classes.==) 'a' c+                                                                              then+                                                                                let _ = "lift2Value checkedHorizon=4"+                                                                                 in let _ = "comment: satisfy ((GHC.Classes.==) 'b')"+                                                                                     in let _ = "checkHorizon.oldCheck: checkedHorizon=4"+                                                                                         in let _ = "checkToken"+                                                                                             in let !(#+                                                                                                       c,+                                                                                                       cs+                                                                                                       #) = readNext cs+                                                                                                 in if (GHC.Classes.==) 'b' c+                                                                                                      then+                                                                                                        let _ = "lift2Value checkedHorizon=3"+                                                                                                         in let _ = "comment: satisfy ((GHC.Classes.==) 'c')"+                                                                                                             in let _ = "checkHorizon.oldCheck: checkedHorizon=3"+                                                                                                                 in let _ = "checkToken"+                                                                                                                     in let !(#+                                                                                                                               c,+                                                                                                                               cs+                                                                                                                               #) = readNext cs+                                                                                                                         in if (GHC.Classes.==) 'c' c+                                                                                                                              then+                                                                                                                                let _ = "lift2Value checkedHorizon=2"+                                                                                                                                 in let _ = "comment: satisfy ((GHC.Classes.==) 'd')"+                                                                                                                                     in let _ = "checkHorizon.oldCheck: checkedHorizon=2"+                                                                                                                                         in let _ = "checkToken"+                                                                                                                                             in let !(#+                                                                                                                                                       c,+                                                                                                                                                       cs+                                                                                                                                                       #) = readNext cs+                                                                                                                                                 in if (GHC.Classes.==) 'd' c+                                                                                                                                                      then+                                                                                                                                                        let _ = "lift2Value checkedHorizon=1"+                                                                                                                                                         in let _ = "commit"+                                                                                                                                                             in let _ = "resume"+                                                                                                                                                                 in callerOnReturn+                                                                                                                                                                      init+                                                                                                                                                                      Data.Set.Internal.empty+                                                                                                                                                                      ( let _ = "resume.genCode"+                                                                                                                                                                         in (GHC.Types.:) 'a' ((GHC.Types.:) 'b' ((GHC.Types.:) 'c' ((GHC.Types.:) 'd' GHC.Types . [])))+                                                                                                                                                                      )+                                                                                                                                                                      cs+                                                                                                                                                      else+                                                                                                                                                        let _ = "checkToken.fail"+                                                                                                                                                         in let failExp =+                                                                                                                                                                  Data.Set.Internal.Bin+                                                                                                                                                                    1+                                                                                                                                                                    ( Symantic.Parser.Grammar.Combinators.SomeFailure+                                                                                                                                                                        ( case inputToken of+                                                                                                                                                                            (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken 'd'+                                                                                                                                                                        )+                                                                                                                                                                    )+                                                                                                                                                                    Data.Set.Internal.Tip+                                                                                                                                                                    Data.Set.Internal.Tip+                                                                                                                                                             in let (#+                                                                                                                                                                      farInp,+                                                                                                                                                                      farExp+                                                                                                                                                                      #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init cs of+                                                                                                                                                                        GHC.Types.LT ->+                                                                                                                                                                          (#+                                                                                                                                                                            cs,+                                                                                                                                                                            failExp+                                                                                                                                                                          #)+                                                                                                                                                                        GHC.Types.EQ ->+                                                                                                                                                                          (#+                                                                                                                                                                            init,+                                                                                                                                                                            failExp GHC.Base.<> Data.Set.Internal.empty+                                                                                                                                                                          #)+                                                                                                                                                                        GHC.Types.GT ->+                                                                                                                                                                          (#+                                                                                                                                                                            init,+                                                                                                                                                                            Data.Set.Internal.empty+                                                                                                                                                                          #)+                                                                                                                                                                 in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure cs farInp farExp+                                                                                                                              else+                                                                                                                                let _ = "checkToken.fail"+                                                                                                                                 in let failExp =+                                                                                                                                          Data.Set.Internal.Bin+                                                                                                                                            1+                                                                                                                                            ( Symantic.Parser.Grammar.Combinators.SomeFailure+                                                                                                                                                ( case inputToken of+                                                                                                                                                    (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken 'c'+                                                                                                                                                )+                                                                                                                                            )+                                                                                                                                            Data.Set.Internal.Tip+                                                                                                                                            Data.Set.Internal.Tip+                                                                                                                                     in let (#+                                                                                                                                              farInp,+                                                                                                                                              farExp+                                                                                                                                              #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init cs of+                                                                                                                                                GHC.Types.LT ->+                                                                                                                                                  (#+                                                                                                                                                    cs,+                                                                                                                                                    failExp+                                                                                                                                                  #)+                                                                                                                                                GHC.Types.EQ ->+                                                                                                                                                  (#+                                                                                                                                                    init,+                                                                                                                                                    failExp GHC.Base.<> Data.Set.Internal.empty+                                                                                                                                                  #)+                                                                                                                                                GHC.Types.GT ->+                                                                                                                                                  (#+                                                                                                                                                    init,+                                                                                                                                                    Data.Set.Internal.empty+                                                                                                                                                  #)+                                                                                                                                         in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure cs farInp farExp+                                                                                                      else+                                                                                                        let _ = "checkToken.fail"+                                                                                                         in let failExp =+                                                                                                                  Data.Set.Internal.Bin+                                                                                                                    1+                                                                                                                    ( Symantic.Parser.Grammar.Combinators.SomeFailure+                                                                                                                        ( case inputToken of+                                                                                                                            (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken 'b'+                                                                                                                        )+                                                                                                                    )+                                                                                                                    Data.Set.Internal.Tip+                                                                                                                    Data.Set.Internal.Tip+                                                                                                             in let (#+                                                                                                                      farInp,+                                                                                                                      farExp+                                                                                                                      #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init cs of+                                                                                                                        GHC.Types.LT ->+                                                                                                                          (#+                                                                                                                            cs,+                                                                                                                            failExp+                                                                                                                          #)+                                                                                                                        GHC.Types.EQ ->+                                                                                                                          (#+                                                                                                                            init,+                                                                                                                            failExp GHC.Base.<> Data.Set.Internal.empty+                                                                                                                          #)+                                                                                                                        GHC.Types.GT ->+                                                                                                                          (#+                                                                                                                            init,+                                                                                                                            Data.Set.Internal.empty+                                                                                                                          #)+                                                                                                                 in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure cs farInp farExp+                                                                              else+                                                                                let _ = "checkToken.fail"+                                                                                 in let failExp =+                                                                                          Data.Set.Internal.Bin+                                                                                            1+                                                                                            ( Symantic.Parser.Grammar.Combinators.SomeFailure+                                                                                                ( case inputToken of+                                                                                                    (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken 'a'+                                                                                                )+                                                                                            )+                                                                                            Data.Set.Internal.Tip+                                                                                            Data.Set.Internal.Tip+                                                                                     in let (#+                                                                                              farInp,+                                                                                              farExp+                                                                                              #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init inp of+                                                                                                GHC.Types.LT ->+                                                                                                  (#+                                                                                                    inp,+                                                                                                    failExp+                                                                                                  #)+                                                                                                GHC.Types.EQ ->+                                                                                                  (#+                                                                                                    init,+                                                                                                    failExp GHC.Base.<> Data.Set.Internal.empty+                                                                                                  #)+                                                                                                GHC.Types.GT ->+                                                                                                  (#+                                                                                                    init,+                                                                                                    Data.Set.Internal.empty+                                                                                                  #)+                                                                                         in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp+                                                                  else+                                                                    let _ = "checkHorizon.newCheck.fail"+                                                                     in let failExp =+                                                                              Data.Set.Internal.Bin+                                                                                1+                                                                                ( Symantic.Parser.Grammar.Combinators.SomeFailure+                                                                                    ( case inputToken of+                                                                                        (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureHorizon @tok' 4+                                                                                    )+                                                                                )+                                                                                Data.Set.Internal.Tip+                                                                                Data.Set.Internal.Tip+                                                                         in let (#+                                                                                  farInp,+                                                                                  farExp+                                                                                  #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init inp of+                                                                                    GHC.Types.LT ->+                                                                                      (#+                                                                                        inp,+                                                                                        failExp+                                                                                      #)+                                                                                    GHC.Types.EQ ->+                                                                                      (#+                                                                                        init,+                                                                                        failExp GHC.Base.<> Data.Set.Internal.empty+                                                                                      #)+                                                                                    GHC.Types.GT ->+                                                                                      (#+                                                                                        init,+                                                                                        Data.Set.Internal.empty+                                                                                      #)+                                                                             in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp+                               in let _ = "pushValue"+                                   in name+                                        ( let _ = "onReturn"+                                           in \farInp farExp v (!inp) ->+                                                let _ = "lift2Value checkedHorizon=0"+                                                 in let _ = "pushValue"+                                                     in do+                                                          let dupv = \x -> x+                                                          reg <- GHC.STRef.newSTRef dupv+                                                          let _ = "iter"+                                                           in let onException loopInput =+                                                                    let _ = "onException"+                                                                     in \(!_exn) (!failInp) (!farInp) (!farExp) ->+                                                                          let _ = "comment: raiseAgainIfConsumed"+                                                                           in let _ = "saveInput checkedHorizon=0"+                                                                               in let _ = "lift2Value checkedHorizon=0"+                                                                                   in if ( \( Data.Text.Internal.Text+                                                                                                _+                                                                                                i+                                                                                                _+                                                                                              )+                                                                                            ( Data.Text.Internal.Text+                                                                                                _+                                                                                                j+                                                                                                _+                                                                                              ) -> i GHC.Classes.== j+                                                                                         )+                                                                                        loopInput+                                                                                        failInp+                                                                                        then+                                                                                          let _ = "choicesBranch checkedHorizon=0"+                                                                                           in do+                                                                                                sr <- GHC.STRef.readSTRef reg+                                                                                                let _ = "pushValue"+                                                                                                 in let _ = "lift2Value checkedHorizon=0"+                                                                                                     in let _ = "lift2Value checkedHorizon=0"+                                                                                                         in let _ = "resume"+                                                                                                             in finalRet+                                                                                                                  farInp+                                                                                                                  farExp+                                                                                                                  ( let _ = "resume.genCode"+                                                                                                                     in GHC.Show.show ((GHC.Types.:) v (sr GHC.Types . []))+                                                                                                                  )+                                                                                                                  failInp+                                                                                        else+                                                                                          let _ = "choicesBranch.else"+                                                                                           in finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp farInp farExp+                                                                  loop = \_callerOnReturn callerInput callerOnExceptionStackByLabel ->+                                                                    let _ = "pushValue"+                                                                     in name+                                                                          ( let _ = "onReturn"+                                                                             in \farInp farExp v (!inp) ->+                                                                                  let _ = "lift2Value checkedHorizon=0"+                                                                                   in let _ = "pushValue"+                                                                                       in let _ = "lift2Value checkedHorizon=0"+                                                                                           in do+                                                                                                sr <- GHC.STRef.readSTRef reg+                                                                                                let _ = "lift2Value checkedHorizon=0"+                                                                                                 in do+                                                                                                      let dupv = \x -> sr ((GHC.Types.:) v x)+                                                                                                      GHC.STRef.writeSTRef reg dupv+                                                                                                      let _ = "jump"+                                                                                                       in loop (GHC.Err.error "invalid onReturn") inp (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure (onException callerInput) Data.Map.Internal.Tip Data.Map.Internal.Tip)+                                                                          )+                                                                          callerInput+                                                                          (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure (onException callerInput) Data.Map.Internal.Tip Data.Map.Internal.Tip)+                                                               in let _ = "jump"+                                                                   in loop finalRet inp Data.Map.Internal.Tip+                                        )+                                        inp+                                        Data.Map.Internal.Tip+                            else+                              let _ = "checkHorizon.newCheck.fail"+                               in let failExp =+                                        Data.Set.Internal.Bin+                                          1+                                          ( Symantic.Parser.Grammar.Combinators.SomeFailure+                                              ( case inputToken of+                                                  (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureHorizon @tok' 4+                                              )+                                          )+                                          Data.Set.Internal.Tip+                                          Data.Set.Internal.Tip+                                   in let (#+                                            farInp,+                                            farExp+                                            #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init inp of+                                              GHC.Types.LT ->+                                                (#+                                                  inp,+                                                  failExp+                                                #)+                                              GHC.Types.EQ ->+                                                (#+                                                  init,+                                                  failExp GHC.Base.<> Data.Set.Internal.empty+                                                #)+                                              GHC.Types.GT ->+                                                (#+                                                  init,+                                                  Data.Set.Internal.empty+                                                #)+                                       in finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp+        )
+ tests/Golden/Splice/G5.expected.txt view
@@ -0,0 +1,535 @@+\(input :: inp) ->+  let !(#+         init,+         readMore,+         readNext+         #) =+          let _ = "cursorOf"+           in let next+                    ( t@( Data.Text.Internal.Text+                            arr+                            off+                            unconsumed+                          )+                      ) =+                      let !( Data.Text.Unsafe.Iter+                               c+                               d+                             ) = Data.Text.Unsafe.iter t 0+                       in (#+                            c,+                            Data.Text.Internal.Text arr (off GHC.Num.+ d) (unconsumed GHC.Num.- d)+                          #)+                  more+                    ( Data.Text.Internal.Text+                        _+                        _+                        unconsumed+                      ) = unconsumed GHC.Classes.> 0+               in (# input, more, next #)+      finalRet = \_farInp _farExp v _inp -> Symantic.Parser.Machine.Generate.returnST GHC.Base.$ Data.Either.Right v+      finalRaise ::+        forall st b.+        Symantic.Parser.Machine.Generate.OnException+          st+          inp+          b = \(!exn) _failInp (!farInp) (!farExp) ->+          Symantic.Parser.Machine.Generate.returnST GHC.Base.$+            Data.Either.Left+              Symantic.Parser.Machine.Generate.ParsingError+                { Symantic.Parser.Machine.Generate.parsingErrorOffset = Symantic.Parser.Machine.Input.offset farInp,+                  Symantic.Parser.Machine.Generate.parsingErrorException = exn,+                  Symantic.Parser.Machine.Generate.parsingErrorUnexpected =+                    if readMore farInp+                      then+                        GHC.Maybe.Just+                          ( let (#+                                  c,+                                  _+                                  #) = readNext farInp+                             in c+                          )+                      else GHC.Maybe.Nothing,+                  Symantic.Parser.Machine.Generate.parsingErrorExpecting =+                    let ( minHoriz,+                          res+                          ) =+                            Data.Set.Internal.foldr+                              ( \f+                                 ( minH,+                                   acc+                                   ) -> case Symantic.Parser.Grammar.Combinators.unSomeFailure f of+                                    GHC.Maybe.Just (Symantic.Parser.Grammar.Combinators.FailureHorizon h :: Symantic.Parser.Grammar.Combinators.Failure (Symantic.Parser.Grammar.Combinators.CombSatisfiable (Symantic.Parser.Machine.Input.InputToken inp)))+                                      | GHC.Maybe.Just old <- minH ->+                                        ( GHC.Maybe.Just (GHC.Classes.min old h),+                                          acc+                                        )+                                      | GHC.Base.otherwise ->+                                        ( GHC.Maybe.Just h,+                                          acc+                                        )+                                    _ ->+                                      ( minH,+                                        f GHC.Types.: acc+                                      )+                              )+                              ( GHC.Maybe.Nothing,+                                GHC.Types . []+                              )+                              farExp+                     in Data.Set.Internal.fromList GHC.Base.$+                          ( case minHoriz of+                              GHC.Maybe.Just h -> Symantic.Parser.Grammar.Combinators.SomeFailure (Symantic.Parser.Grammar.Combinators.FailureHorizon @(Symantic.Parser.Machine.Input.InputToken inp) h) GHC.Types.: res+                              GHC.Maybe.Nothing -> res+                          )+                }+   in GHC.ST.runST+        ( let inputToken = Data.Proxy.Proxy :: Data.Proxy.Proxy (Symantic.Parser.Machine.Input.InputToken inp)+           in let inp = init+               in let readFail = finalRaise+                   in let _ = "checkHorizon.newCheck: checkedHorizon=0 minHoriz=4"+                       in if readMore (Symantic.Parser.Machine.Input.shiftRightText 3 inp)+                            then+                              let name = \(!callerOnReturn) (!callerInput) (!callerOnExceptionStackByLabel) ->+                                    let _ = "catch ExceptionFailure checkedHorizon=0"+                                     in let onException =+                                              let _ = "onException"+                                               in \(!_exn) (!failInp) (!farInp) (!farExp) ->+                                                    let _ = "loadInput checkedHorizon=0"+                                                     in let _ = "checkHorizon.noCheck"+                                                         in Data.Map.Strict.Internal.findWithDefault finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure callerOnExceptionStackByLabel Symantic.Parser.Grammar.Combinators.ExceptionFailure callerInput farInp farExp+                                         in let _ = "pushValue"+                                             in let _ = "comment: satisfy ((GHC.Classes.==) 'a')"+                                                 in let inp = callerInput+                                                     in let readFail = onException+                                                         in let _ = "checkHorizon.newCheck: checkedHorizon=0 minHoriz=4"+                                                             in if readMore (Symantic.Parser.Machine.Input.shiftRightText 3 inp)+                                                                  then+                                                                    let _ = "checkToken"+                                                                     in let !(#+                                                                               c,+                                                                               cs+                                                                               #) = readNext inp+                                                                         in if (GHC.Classes.==) 'a' c+                                                                              then+                                                                                let _ = "lift2Value checkedHorizon=4"+                                                                                 in let _ = "comment: satisfy ((GHC.Classes.==) 'b')"+                                                                                     in let _ = "checkHorizon.oldCheck: checkedHorizon=4"+                                                                                         in let _ = "checkToken"+                                                                                             in let !(#+                                                                                                       c,+                                                                                                       cs+                                                                                                       #) = readNext cs+                                                                                                 in if (GHC.Classes.==) 'b' c+                                                                                                      then+                                                                                                        let _ = "lift2Value checkedHorizon=3"+                                                                                                         in let _ = "comment: satisfy ((GHC.Classes.==) 'c')"+                                                                                                             in let _ = "checkHorizon.oldCheck: checkedHorizon=3"+                                                                                                                 in let _ = "checkToken"+                                                                                                                     in let !(#+                                                                                                                               c,+                                                                                                                               cs+                                                                                                                               #) = readNext cs+                                                                                                                         in if (GHC.Classes.==) 'c' c+                                                                                                                              then+                                                                                                                                let _ = "lift2Value checkedHorizon=2"+                                                                                                                                 in let _ = "comment: satisfy ((GHC.Classes.==) 'd')"+                                                                                                                                     in let _ = "checkHorizon.oldCheck: checkedHorizon=2"+                                                                                                                                         in let _ = "checkToken"+                                                                                                                                             in let !(#+                                                                                                                                                       c,+                                                                                                                                                       cs+                                                                                                                                                       #) = readNext cs+                                                                                                                                                 in if (GHC.Classes.==) 'd' c+                                                                                                                                                      then+                                                                                                                                                        let _ = "lift2Value checkedHorizon=1"+                                                                                                                                                         in let _ = "commit"+                                                                                                                                                             in let _ = "resume"+                                                                                                                                                                 in callerOnReturn+                                                                                                                                                                      init+                                                                                                                                                                      Data.Set.Internal.empty+                                                                                                                                                                      ( let _ = "resume.genCode"+                                                                                                                                                                         in (GHC.Types.:) 'a' ((GHC.Types.:) 'b' ((GHC.Types.:) 'c' ((GHC.Types.:) 'd' GHC.Types . [])))+                                                                                                                                                                      )+                                                                                                                                                                      cs+                                                                                                                                                      else+                                                                                                                                                        let _ = "checkToken.fail"+                                                                                                                                                         in let failExp =+                                                                                                                                                                  Data.Set.Internal.Bin+                                                                                                                                                                    1+                                                                                                                                                                    ( Symantic.Parser.Grammar.Combinators.SomeFailure+                                                                                                                                                                        ( case inputToken of+                                                                                                                                                                            (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken 'd'+                                                                                                                                                                        )+                                                                                                                                                                    )+                                                                                                                                                                    Data.Set.Internal.Tip+                                                                                                                                                                    Data.Set.Internal.Tip+                                                                                                                                                             in let (#+                                                                                                                                                                      farInp,+                                                                                                                                                                      farExp+                                                                                                                                                                      #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init cs of+                                                                                                                                                                        GHC.Types.LT ->+                                                                                                                                                                          (#+                                                                                                                                                                            cs,+                                                                                                                                                                            failExp+                                                                                                                                                                          #)+                                                                                                                                                                        GHC.Types.EQ ->+                                                                                                                                                                          (#+                                                                                                                                                                            init,+                                                                                                                                                                            failExp GHC.Base.<> Data.Set.Internal.empty+                                                                                                                                                                          #)+                                                                                                                                                                        GHC.Types.GT ->+                                                                                                                                                                          (#+                                                                                                                                                                            init,+                                                                                                                                                                            Data.Set.Internal.empty+                                                                                                                                                                          #)+                                                                                                                                                                 in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure cs farInp farExp+                                                                                                                              else+                                                                                                                                let _ = "checkToken.fail"+                                                                                                                                 in let failExp =+                                                                                                                                          Data.Set.Internal.Bin+                                                                                                                                            1+                                                                                                                                            ( Symantic.Parser.Grammar.Combinators.SomeFailure+                                                                                                                                                ( case inputToken of+                                                                                                                                                    (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken 'c'+                                                                                                                                                )+                                                                                                                                            )+                                                                                                                                            Data.Set.Internal.Tip+                                                                                                                                            Data.Set.Internal.Tip+                                                                                                                                     in let (#+                                                                                                                                              farInp,+                                                                                                                                              farExp+                                                                                                                                              #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init cs of+                                                                                                                                                GHC.Types.LT ->+                                                                                                                                                  (#+                                                                                                                                                    cs,+                                                                                                                                                    failExp+                                                                                                                                                  #)+                                                                                                                                                GHC.Types.EQ ->+                                                                                                                                                  (#+                                                                                                                                                    init,+                                                                                                                                                    failExp GHC.Base.<> Data.Set.Internal.empty+                                                                                                                                                  #)+                                                                                                                                                GHC.Types.GT ->+                                                                                                                                                  (#+                                                                                                                                                    init,+                                                                                                                                                    Data.Set.Internal.empty+                                                                                                                                                  #)+                                                                                                                                         in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure cs farInp farExp+                                                                                                      else+                                                                                                        let _ = "checkToken.fail"+                                                                                                         in let failExp =+                                                                                                                  Data.Set.Internal.Bin+                                                                                                                    1+                                                                                                                    ( Symantic.Parser.Grammar.Combinators.SomeFailure+                                                                                                                        ( case inputToken of+                                                                                                                            (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken 'b'+                                                                                                                        )+                                                                                                                    )+                                                                                                                    Data.Set.Internal.Tip+                                                                                                                    Data.Set.Internal.Tip+                                                                                                             in let (#+                                                                                                                      farInp,+                                                                                                                      farExp+                                                                                                                      #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init cs of+                                                                                                                        GHC.Types.LT ->+                                                                                                                          (#+                                                                                                                            cs,+                                                                                                                            failExp+                                                                                                                          #)+                                                                                                                        GHC.Types.EQ ->+                                                                                                                          (#+                                                                                                                            init,+                                                                                                                            failExp GHC.Base.<> Data.Set.Internal.empty+                                                                                                                          #)+                                                                                                                        GHC.Types.GT ->+                                                                                                                          (#+                                                                                                                            init,+                                                                                                                            Data.Set.Internal.empty+                                                                                                                          #)+                                                                                                                 in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure cs farInp farExp+                                                                              else+                                                                                let _ = "checkToken.fail"+                                                                                 in let failExp =+                                                                                          Data.Set.Internal.Bin+                                                                                            1+                                                                                            ( Symantic.Parser.Grammar.Combinators.SomeFailure+                                                                                                ( case inputToken of+                                                                                                    (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken 'a'+                                                                                                )+                                                                                            )+                                                                                            Data.Set.Internal.Tip+                                                                                            Data.Set.Internal.Tip+                                                                                     in let (#+                                                                                              farInp,+                                                                                              farExp+                                                                                              #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init inp of+                                                                                                GHC.Types.LT ->+                                                                                                  (#+                                                                                                    inp,+                                                                                                    failExp+                                                                                                  #)+                                                                                                GHC.Types.EQ ->+                                                                                                  (#+                                                                                                    init,+                                                                                                    failExp GHC.Base.<> Data.Set.Internal.empty+                                                                                                  #)+                                                                                                GHC.Types.GT ->+                                                                                                  (#+                                                                                                    init,+                                                                                                    Data.Set.Internal.empty+                                                                                                  #)+                                                                                         in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp+                                                                  else+                                                                    let _ = "checkHorizon.newCheck.fail"+                                                                     in let failExp =+                                                                              Data.Set.Internal.Bin+                                                                                1+                                                                                ( Symantic.Parser.Grammar.Combinators.SomeFailure+                                                                                    ( case inputToken of+                                                                                        (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureHorizon @tok' 4+                                                                                    )+                                                                                )+                                                                                Data.Set.Internal.Tip+                                                                                Data.Set.Internal.Tip+                                                                         in let (#+                                                                                  farInp,+                                                                                  farExp+                                                                                  #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init inp of+                                                                                    GHC.Types.LT ->+                                                                                      (#+                                                                                        inp,+                                                                                        failExp+                                                                                      #)+                                                                                    GHC.Types.EQ ->+                                                                                      (#+                                                                                        init,+                                                                                        failExp GHC.Base.<> Data.Set.Internal.empty+                                                                                      #)+                                                                                    GHC.Types.GT ->+                                                                                      (#+                                                                                        init,+                                                                                        Data.Set.Internal.empty+                                                                                      #)+                                                                             in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp+                               in let _ = "pushValue"+                                   in name+                                        ( let _ = "onReturn"+                                           in \farInp farExp v (!inp) ->+                                                let _ = "lift2Value checkedHorizon=0"+                                                 in let _ = "pushValue"+                                                     in do+                                                          let dupv = \x -> x+                                                          reg <- GHC.STRef.newSTRef dupv+                                                          let _ = "iter"+                                                           in let onException loopInput =+                                                                    let _ = "onException"+                                                                     in \(!_exn) (!failInp) (!farInp) (!farExp) ->+                                                                          let _ = "comment: raiseAgainIfConsumed"+                                                                           in let _ = "saveInput checkedHorizon=0"+                                                                               in let _ = "lift2Value checkedHorizon=0"+                                                                                   in if ( \( Data.Text.Internal.Text+                                                                                                _+                                                                                                i+                                                                                                _+                                                                                              )+                                                                                            ( Data.Text.Internal.Text+                                                                                                _+                                                                                                j+                                                                                                _+                                                                                              ) -> i GHC.Classes.== j+                                                                                         )+                                                                                        loopInput+                                                                                        failInp+                                                                                        then+                                                                                          let _ = "choicesBranch checkedHorizon=0"+                                                                                           in do+                                                                                                sr <- GHC.STRef.readSTRef reg+                                                                                                let _ = "pushValue"+                                                                                                 in let _ = "lift2Value checkedHorizon=0"+                                                                                                     in let _ = "lift2Value checkedHorizon=0"+                                                                                                         in let join = \farInp farExp v (!inp) ->+                                                                                                                  let _ = "lift2Value checkedHorizon=0"+                                                                                                                   in let _ = "resume"+                                                                                                                       in finalRet+                                                                                                                            farInp+                                                                                                                            farExp+                                                                                                                            ( let _ = "resume.genCode"+                                                                                                                               in GHC.Show.show ((GHC.Types.:) v (sr GHC.Types . []))+                                                                                                                            )+                                                                                                                            inp+                                                                                                             in let _ = "catch ExceptionFailure checkedHorizon=0"+                                                                                                                 in let onException =+                                                                                                                          let _ = "onException"+                                                                                                                           in \(!_exn) (!failInp) (!farInp) (!farExp) ->+                                                                                                                                let _ = "comment: raiseAgainIfConsumed"+                                                                                                                                 in let _ = "saveInput checkedHorizon=0"+                                                                                                                                     in let _ = "lift2Value checkedHorizon=0"+                                                                                                                                         in if ( \( Data.Text.Internal.Text+                                                                                                                                                      _+                                                                                                                                                      i+                                                                                                                                                      _+                                                                                                                                                    )+                                                                                                                                                  ( Data.Text.Internal.Text+                                                                                                                                                      _+                                                                                                                                                      j+                                                                                                                                                      _+                                                                                                                                                    ) -> i GHC.Classes.== j+                                                                                                                                               )+                                                                                                                                              failInp+                                                                                                                                              failInp+                                                                                                                                              then+                                                                                                                                                let _ = "choicesBranch checkedHorizon=0"+                                                                                                                                                 in let _ = "comment: eof.fail"+                                                                                                                                                     in let failExp = Data.Set.Internal.Bin 1 (Symantic.Parser.Grammar.Combinators.SomeFailure Symantic.Parser.Grammar.Combinators.FailureEnd) Data.Set.Internal.Tip Data.Set.Internal.Tip+                                                                                                                                                         in let (#+                                                                                                                                                                  farInp,+                                                                                                                                                                  farExp+                                                                                                                                                                  #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp failInp of+                                                                                                                                                                    GHC.Types.LT ->+                                                                                                                                                                      (#+                                                                                                                                                                        failInp,+                                                                                                                                                                        failExp+                                                                                                                                                                      #)+                                                                                                                                                                    GHC.Types.EQ ->+                                                                                                                                                                      (#+                                                                                                                                                                        farInp,+                                                                                                                                                                        failExp GHC.Base.<> farExp+                                                                                                                                                                      #)+                                                                                                                                                                    GHC.Types.GT ->+                                                                                                                                                                      (#+                                                                                                                                                                        farInp,+                                                                                                                                                                        farExp+                                                                                                                                                                      #)+                                                                                                                                                             in finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp farInp farExp+                                                                                                                                              else+                                                                                                                                                let _ = "choicesBranch.else"+                                                                                                                                                 in finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp farInp farExp+                                                                                                                     in let _ = "comment: negLook"+                                                                                                                         in let _ = "catch ExceptionFailure checkedHorizon=0"+                                                                                                                             in let onException =+                                                                                                                                      let _ = "onException"+                                                                                                                                       in \(!_exn) (!failInp) (!farInp) (!farExp) ->+                                                                                                                                            let _ = "comment: negLook.reset"+                                                                                                                                             in let _ = "loadInput checkedHorizon=0"+                                                                                                                                                 in let _ = "checkHorizon.noCheck"+                                                                                                                                                     in let _ = "pushValue"+                                                                                                                                                         in let _ = "commit"+                                                                                                                                                             in let _ = "resume"+                                                                                                                                                                 in join+                                                                                                                                                                      farInp+                                                                                                                                                                      farExp+                                                                                                                                                                      ( let _ = "resume.genCode"+                                                                                                                                                                         in GHC.Tuple . ()+                                                                                                                                                                      )+                                                                                                                                                                      failInp+                                                                                                                                 in let _ = "comment: negLook.ahead"+                                                                                                                                     in let _ = "saveInput checkedHorizon=0"+                                                                                                                                         in let _ = "comment: satisfy ((\\x_0 -> \\x_1 -> x_0) GHC.Types.True)"+                                                                                                                                             in let inp = failInp+                                                                                                                                                 in let readFail = onException+                                                                                                                                                     in let _ = "checkHorizon.newCheck: checkedHorizon=0 minHoriz=1"+                                                                                                                                                         in if readMore inp+                                                                                                                                                              then+                                                                                                                                                                let _ = "checkToken"+                                                                                                                                                                 in let !(#+                                                                                                                                                                           c,+                                                                                                                                                                           cs+                                                                                                                                                                           #) = readNext inp+                                                                                                                                                                     in let _ = "popValue"+                                                                                                                                                                         in let _ = "commit"+                                                                                                                                                                             in let _ = "loadInput checkedHorizon=0"+                                                                                                                                                                                 in let _ = "checkHorizon.noCheck"+                                                                                                                                                                                     in onException Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp farInp farExp+                                                                                                                                                              else+                                                                                                                                                                let _ = "checkHorizon.newCheck.fail"+                                                                                                                                                                 in let failExp =+                                                                                                                                                                          Data.Set.Internal.Bin+                                                                                                                                                                            1+                                                                                                                                                                            ( Symantic.Parser.Grammar.Combinators.SomeFailure+                                                                                                                                                                                ( case inputToken of+                                                                                                                                                                                    (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureHorizon @tok' 1+                                                                                                                                                                                )+                                                                                                                                                                            )+                                                                                                                                                                            Data.Set.Internal.Tip+                                                                                                                                                                            Data.Set.Internal.Tip+                                                                                                                                                                     in let (#+                                                                                                                                                                              farInp,+                                                                                                                                                                              farExp+                                                                                                                                                                              #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp inp of+                                                                                                                                                                                GHC.Types.LT ->+                                                                                                                                                                                  (#+                                                                                                                                                                                    inp,+                                                                                                                                                                                    failExp+                                                                                                                                                                                  #)+                                                                                                                                                                                GHC.Types.EQ ->+                                                                                                                                                                                  (#+                                                                                                                                                                                    farInp,+                                                                                                                                                                                    failExp GHC.Base.<> farExp+                                                                                                                                                                                  #)+                                                                                                                                                                                GHC.Types.GT ->+                                                                                                                                                                                  (#+                                                                                                                                                                                    farInp,+                                                                                                                                                                                    farExp+                                                                                                                                                                                  #)+                                                                                                                                                                         in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp+                                                                                        else+                                                                                          let _ = "choicesBranch.else"+                                                                                           in finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp farInp farExp+                                                                  loop = \_callerOnReturn callerInput callerOnExceptionStackByLabel ->+                                                                    let _ = "pushValue"+                                                                     in name+                                                                          ( let _ = "onReturn"+                                                                             in \farInp farExp v (!inp) ->+                                                                                  let _ = "lift2Value checkedHorizon=0"+                                                                                   in let _ = "pushValue"+                                                                                       in let _ = "lift2Value checkedHorizon=0"+                                                                                           in do+                                                                                                sr <- GHC.STRef.readSTRef reg+                                                                                                let _ = "lift2Value checkedHorizon=0"+                                                                                                 in do+                                                                                                      let dupv = \x -> sr ((GHC.Types.:) v x)+                                                                                                      GHC.STRef.writeSTRef reg dupv+                                                                                                      let _ = "jump"+                                                                                                       in loop (GHC.Err.error "invalid onReturn") inp (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure (onException callerInput) Data.Map.Internal.Tip Data.Map.Internal.Tip)+                                                                          )+                                                                          callerInput+                                                                          (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure (onException callerInput) Data.Map.Internal.Tip Data.Map.Internal.Tip)+                                                               in let _ = "jump"+                                                                   in loop finalRet inp Data.Map.Internal.Tip+                                        )+                                        inp+                                        Data.Map.Internal.Tip+                            else+                              let _ = "checkHorizon.newCheck.fail"+                               in let failExp =+                                        Data.Set.Internal.Bin+                                          1+                                          ( Symantic.Parser.Grammar.Combinators.SomeFailure+                                              ( case inputToken of+                                                  (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureHorizon @tok' 4+                                              )+                                          )+                                          Data.Set.Internal.Tip+                                          Data.Set.Internal.Tip+                                   in let (#+                                            farInp,+                                            farExp+                                            #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init inp of+                                              GHC.Types.LT ->+                                                (#+                                                  inp,+                                                  failExp+                                                #)+                                              GHC.Types.EQ ->+                                                (#+                                                  init,+                                                  failExp GHC.Base.<> Data.Set.Internal.empty+                                                #)+                                              GHC.Types.GT ->+                                                (#+                                                  init,+                                                  Data.Set.Internal.empty+                                                #)+                                       in finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp+        )
+ tests/Golden/Splice/G6.expected.txt view
@@ -0,0 +1,385 @@+\(input :: inp) ->+  let !(#+         init,+         readMore,+         readNext+         #) =+          let _ = "cursorOf"+           in let next+                    ( t@( Data.Text.Internal.Text+                            arr+                            off+                            unconsumed+                          )+                      ) =+                      let !( Data.Text.Unsafe.Iter+                               c+                               d+                             ) = Data.Text.Unsafe.iter t 0+                       in (#+                            c,+                            Data.Text.Internal.Text arr (off GHC.Num.+ d) (unconsumed GHC.Num.- d)+                          #)+                  more+                    ( Data.Text.Internal.Text+                        _+                        _+                        unconsumed+                      ) = unconsumed GHC.Classes.> 0+               in (# input, more, next #)+      finalRet = \_farInp _farExp v _inp -> Symantic.Parser.Machine.Generate.returnST GHC.Base.$ Data.Either.Right v+      finalRaise ::+        forall st b.+        Symantic.Parser.Machine.Generate.OnException+          st+          inp+          b = \(!exn) _failInp (!farInp) (!farExp) ->+          Symantic.Parser.Machine.Generate.returnST GHC.Base.$+            Data.Either.Left+              Symantic.Parser.Machine.Generate.ParsingError+                { Symantic.Parser.Machine.Generate.parsingErrorOffset = Symantic.Parser.Machine.Input.offset farInp,+                  Symantic.Parser.Machine.Generate.parsingErrorException = exn,+                  Symantic.Parser.Machine.Generate.parsingErrorUnexpected =+                    if readMore farInp+                      then+                        GHC.Maybe.Just+                          ( let (#+                                  c,+                                  _+                                  #) = readNext farInp+                             in c+                          )+                      else GHC.Maybe.Nothing,+                  Symantic.Parser.Machine.Generate.parsingErrorExpecting =+                    let ( minHoriz,+                          res+                          ) =+                            Data.Set.Internal.foldr+                              ( \f+                                 ( minH,+                                   acc+                                   ) -> case Symantic.Parser.Grammar.Combinators.unSomeFailure f of+                                    GHC.Maybe.Just (Symantic.Parser.Grammar.Combinators.FailureHorizon h :: Symantic.Parser.Grammar.Combinators.Failure (Symantic.Parser.Grammar.Combinators.CombSatisfiable (Symantic.Parser.Machine.Input.InputToken inp)))+                                      | GHC.Maybe.Just old <- minH ->+                                        ( GHC.Maybe.Just (GHC.Classes.min old h),+                                          acc+                                        )+                                      | GHC.Base.otherwise ->+                                        ( GHC.Maybe.Just h,+                                          acc+                                        )+                                    _ ->+                                      ( minH,+                                        f GHC.Types.: acc+                                      )+                              )+                              ( GHC.Maybe.Nothing,+                                GHC.Types . []+                              )+                              farExp+                     in Data.Set.Internal.fromList GHC.Base.$+                          ( case minHoriz of+                              GHC.Maybe.Just h -> Symantic.Parser.Grammar.Combinators.SomeFailure (Symantic.Parser.Grammar.Combinators.FailureHorizon @(Symantic.Parser.Machine.Input.InputToken inp) h) GHC.Types.: res+                              GHC.Maybe.Nothing -> res+                          )+                }+   in GHC.ST.runST+        ( let inputToken = Data.Proxy.Proxy :: Data.Proxy.Proxy (Symantic.Parser.Machine.Input.InputToken inp)+           in let inp = init+               in let readFail = finalRaise+                   in let _ = "checkHorizon.newCheck: checkedHorizon=0 minHoriz=2"+                       in if readMore (Symantic.Parser.Machine.Input.shiftRightText 1 inp)+                            then+                              let+                               in let _ = "pushValue"+                                   in let join = \farInp farExp v (!inp) ->+                                            let _ = "lift2Value checkedHorizon=0"+                                             in let _ = "resume"+                                                 in finalRet+                                                      farInp+                                                      farExp+                                                      ( let _ = "resume.genCode"+                                                         in GHC.Show.show v+                                                      )+                                                      inp+                                       in let _ = "catch ExceptionFailure checkedHorizon=2"+                                           in let onException =+                                                    let _ = "onException"+                                                     in \(!_exn) (!failInp) (!farInp) (!farExp) ->+                                                          let _ = "comment: raiseAgainIfConsumed"+                                                           in let _ = "saveInput checkedHorizon=0"+                                                               in let _ = "lift2Value checkedHorizon=0"+                                                                   in if ( \( Data.Text.Internal.Text+                                                                                _+                                                                                i+                                                                                _+                                                                              )+                                                                            ( Data.Text.Internal.Text+                                                                                _+                                                                                j+                                                                                _+                                                                              ) -> i GHC.Classes.== j+                                                                         )+                                                                        inp+                                                                        failInp+                                                                        then+                                                                          let _ = "choicesBranch checkedHorizon=0"+                                                                           in let _ = "pushValue"+                                                                               in let _ = "comment: satisfy ((GHC.Classes.==) 'a')"+                                                                                   in let inp = failInp+                                                                                       in let readFail = finalRaise+                                                                                           in let _ = "checkHorizon.newCheck: checkedHorizon=0 minHoriz=2"+                                                                                               in if readMore (Symantic.Parser.Machine.Input.shiftRightText 1 inp)+                                                                                                    then+                                                                                                      let _ = "checkToken"+                                                                                                       in let !(#+                                                                                                                 c,+                                                                                                                 cs+                                                                                                                 #) = readNext inp+                                                                                                           in if (GHC.Classes.==) 'a' c+                                                                                                                then+                                                                                                                  let _ = "lift2Value checkedHorizon=2"+                                                                                                                   in let _ = "comment: satisfy ((GHC.Classes.==) 'b')"+                                                                                                                       in let _ = "checkHorizon.oldCheck: checkedHorizon=2"+                                                                                                                           in let _ = "checkToken"+                                                                                                                               in let !(#+                                                                                                                                         c,+                                                                                                                                         cs+                                                                                                                                         #) = readNext cs+                                                                                                                                   in if (GHC.Classes.==) 'b' c+                                                                                                                                        then+                                                                                                                                          let _ = "lift2Value checkedHorizon=1"+                                                                                                                                           in let _ = "resume"+                                                                                                                                               in join+                                                                                                                                                    farInp+                                                                                                                                                    farExp+                                                                                                                                                    ( let _ = "resume.genCode"+                                                                                                                                                       in (GHC.Types.:) 'a' ((GHC.Types.:) 'b' GHC.Types . [])+                                                                                                                                                    )+                                                                                                                                                    cs+                                                                                                                                        else+                                                                                                                                          let _ = "checkToken.fail"+                                                                                                                                           in let failExp =+                                                                                                                                                    Data.Set.Internal.Bin+                                                                                                                                                      1+                                                                                                                                                      ( Symantic.Parser.Grammar.Combinators.SomeFailure+                                                                                                                                                          ( case inputToken of+                                                                                                                                                              (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken 'b'+                                                                                                                                                          )+                                                                                                                                                      )+                                                                                                                                                      Data.Set.Internal.Tip+                                                                                                                                                      Data.Set.Internal.Tip+                                                                                                                                               in let (#+                                                                                                                                                        farInp,+                                                                                                                                                        farExp+                                                                                                                                                        #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp cs of+                                                                                                                                                          GHC.Types.LT ->+                                                                                                                                                            (#+                                                                                                                                                              cs,+                                                                                                                                                              failExp+                                                                                                                                                            #)+                                                                                                                                                          GHC.Types.EQ ->+                                                                                                                                                            (#+                                                                                                                                                              farInp,+                                                                                                                                                              failExp GHC.Base.<> farExp+                                                                                                                                                            #)+                                                                                                                                                          GHC.Types.GT ->+                                                                                                                                                            (#+                                                                                                                                                              farInp,+                                                                                                                                                              farExp+                                                                                                                                                            #)+                                                                                                                                                   in finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure cs farInp farExp+                                                                                                                else+                                                                                                                  let _ = "checkToken.fail"+                                                                                                                   in let failExp =+                                                                                                                            Data.Set.Internal.Bin+                                                                                                                              1+                                                                                                                              ( Symantic.Parser.Grammar.Combinators.SomeFailure+                                                                                                                                  ( case inputToken of+                                                                                                                                      (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken 'a'+                                                                                                                                  )+                                                                                                                              )+                                                                                                                              Data.Set.Internal.Tip+                                                                                                                              Data.Set.Internal.Tip+                                                                                                                       in let (#+                                                                                                                                farInp,+                                                                                                                                farExp+                                                                                                                                #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp inp of+                                                                                                                                  GHC.Types.LT ->+                                                                                                                                    (#+                                                                                                                                      inp,+                                                                                                                                      failExp+                                                                                                                                    #)+                                                                                                                                  GHC.Types.EQ ->+                                                                                                                                    (#+                                                                                                                                      farInp,+                                                                                                                                      failExp GHC.Base.<> farExp+                                                                                                                                    #)+                                                                                                                                  GHC.Types.GT ->+                                                                                                                                    (#+                                                                                                                                      farInp,+                                                                                                                                      farExp+                                                                                                                                    #)+                                                                                                                           in finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp+                                                                                                    else+                                                                                                      let _ = "checkHorizon.newCheck.fail"+                                                                                                       in let failExp =+                                                                                                                Data.Set.Internal.Bin+                                                                                                                  1+                                                                                                                  ( Symantic.Parser.Grammar.Combinators.SomeFailure+                                                                                                                      ( case inputToken of+                                                                                                                          (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureHorizon @tok' 2+                                                                                                                      )+                                                                                                                  )+                                                                                                                  Data.Set.Internal.Tip+                                                                                                                  Data.Set.Internal.Tip+                                                                                                           in let (#+                                                                                                                    farInp,+                                                                                                                    farExp+                                                                                                                    #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp inp of+                                                                                                                      GHC.Types.LT ->+                                                                                                                        (#+                                                                                                                          inp,+                                                                                                                          failExp+                                                                                                                        #)+                                                                                                                      GHC.Types.EQ ->+                                                                                                                        (#+                                                                                                                          farInp,+                                                                                                                          failExp GHC.Base.<> farExp+                                                                                                                        #)+                                                                                                                      GHC.Types.GT ->+                                                                                                                        (#+                                                                                                                          farInp,+                                                                                                                          farExp+                                                                                                                        #)+                                                                                                               in finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp+                                                                        else+                                                                          let _ = "choicesBranch.else"+                                                                           in finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp farInp farExp+                                               in let _ = "pushValue"+                                                   in let _ = "comment: satisfy ((GHC.Classes.==) 'a')"+                                                       in let _ = "checkHorizon.oldCheck: checkedHorizon=2"+                                                           in let _ = "checkToken"+                                                               in let !(#+                                                                         c,+                                                                         cs+                                                                         #) = readNext inp+                                                                   in if (GHC.Classes.==) 'a' c+                                                                        then+                                                                          let _ = "lift2Value checkedHorizon=1"+                                                                           in let _ = "comment: satisfy ((GHC.Classes.==) 'a')"+                                                                               in let _ = "checkHorizon.oldCheck: checkedHorizon=1"+                                                                                   in let _ = "checkToken"+                                                                                       in let !(#+                                                                                                 c,+                                                                                                 cs+                                                                                                 #) = readNext cs+                                                                                           in if (GHC.Classes.==) 'a' c+                                                                                                then+                                                                                                  let _ = "lift2Value checkedHorizon=0"+                                                                                                   in let _ = "commit"+                                                                                                       in let _ = "resume"+                                                                                                           in join+                                                                                                                init+                                                                                                                Data.Set.Internal.empty+                                                                                                                ( let _ = "resume.genCode"+                                                                                                                   in (GHC.Types.:) 'a' ((GHC.Types.:) 'a' GHC.Types . [])+                                                                                                                )+                                                                                                                cs+                                                                                                else+                                                                                                  let _ = "checkToken.fail"+                                                                                                   in let failExp =+                                                                                                            Data.Set.Internal.Bin+                                                                                                              1+                                                                                                              ( Symantic.Parser.Grammar.Combinators.SomeFailure+                                                                                                                  ( case inputToken of+                                                                                                                      (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken 'a'+                                                                                                                  )+                                                                                                              )+                                                                                                              Data.Set.Internal.Tip+                                                                                                              Data.Set.Internal.Tip+                                                                                                       in let (#+                                                                                                                farInp,+                                                                                                                farExp+                                                                                                                #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init cs of+                                                                                                                  GHC.Types.LT ->+                                                                                                                    (#+                                                                                                                      cs,+                                                                                                                      failExp+                                                                                                                    #)+                                                                                                                  GHC.Types.EQ ->+                                                                                                                    (#+                                                                                                                      init,+                                                                                                                      failExp GHC.Base.<> Data.Set.Internal.empty+                                                                                                                    #)+                                                                                                                  GHC.Types.GT ->+                                                                                                                    (#+                                                                                                                      init,+                                                                                                                      Data.Set.Internal.empty+                                                                                                                    #)+                                                                                                           in onException Symantic.Parser.Grammar.Combinators.ExceptionFailure cs farInp farExp+                                                                        else+                                                                          let _ = "checkToken.fail"+                                                                           in let failExp =+                                                                                    Data.Set.Internal.Bin+                                                                                      1+                                                                                      ( Symantic.Parser.Grammar.Combinators.SomeFailure+                                                                                          ( case inputToken of+                                                                                              (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken 'a'+                                                                                          )+                                                                                      )+                                                                                      Data.Set.Internal.Tip+                                                                                      Data.Set.Internal.Tip+                                                                               in let (#+                                                                                        farInp,+                                                                                        farExp+                                                                                        #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init inp of+                                                                                          GHC.Types.LT ->+                                                                                            (#+                                                                                              inp,+                                                                                              failExp+                                                                                            #)+                                                                                          GHC.Types.EQ ->+                                                                                            (#+                                                                                              init,+                                                                                              failExp GHC.Base.<> Data.Set.Internal.empty+                                                                                            #)+                                                                                          GHC.Types.GT ->+                                                                                            (#+                                                                                              init,+                                                                                              Data.Set.Internal.empty+                                                                                            #)+                                                                                   in onException Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp+                            else+                              let _ = "checkHorizon.newCheck.fail"+                               in let failExp =+                                        Data.Set.Internal.Bin+                                          1+                                          ( Symantic.Parser.Grammar.Combinators.SomeFailure+                                              ( case inputToken of+                                                  (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureHorizon @tok' 2+                                              )+                                          )+                                          Data.Set.Internal.Tip+                                          Data.Set.Internal.Tip+                                   in let (#+                                            farInp,+                                            farExp+                                            #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init inp of+                                              GHC.Types.LT ->+                                                (#+                                                  inp,+                                                  failExp+                                                #)+                                              GHC.Types.EQ ->+                                                (#+                                                  init,+                                                  failExp GHC.Base.<> Data.Set.Internal.empty+                                                #)+                                              GHC.Types.GT ->+                                                (#+                                                  init,+                                                  Data.Set.Internal.empty+                                                #)+                                       in finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp+        )
+ tests/Golden/Splice/G7.expected.txt view
@@ -0,0 +1,401 @@+\(input :: inp) ->+  let !(#+         init,+         readMore,+         readNext+         #) =+          let _ = "cursorOf"+           in let next+                    ( t@( Data.Text.Internal.Text+                            arr+                            off+                            unconsumed+                          )+                      ) =+                      let !( Data.Text.Unsafe.Iter+                               c+                               d+                             ) = Data.Text.Unsafe.iter t 0+                       in (#+                            c,+                            Data.Text.Internal.Text arr (off GHC.Num.+ d) (unconsumed GHC.Num.- d)+                          #)+                  more+                    ( Data.Text.Internal.Text+                        _+                        _+                        unconsumed+                      ) = unconsumed GHC.Classes.> 0+               in (# input, more, next #)+      finalRet = \_farInp _farExp v _inp -> Symantic.Parser.Machine.Generate.returnST GHC.Base.$ Data.Either.Right v+      finalRaise ::+        forall st b.+        Symantic.Parser.Machine.Generate.OnException+          st+          inp+          b = \(!exn) _failInp (!farInp) (!farExp) ->+          Symantic.Parser.Machine.Generate.returnST GHC.Base.$+            Data.Either.Left+              Symantic.Parser.Machine.Generate.ParsingError+                { Symantic.Parser.Machine.Generate.parsingErrorOffset = Symantic.Parser.Machine.Input.offset farInp,+                  Symantic.Parser.Machine.Generate.parsingErrorException = exn,+                  Symantic.Parser.Machine.Generate.parsingErrorUnexpected =+                    if readMore farInp+                      then+                        GHC.Maybe.Just+                          ( let (#+                                  c,+                                  _+                                  #) = readNext farInp+                             in c+                          )+                      else GHC.Maybe.Nothing,+                  Symantic.Parser.Machine.Generate.parsingErrorExpecting =+                    let ( minHoriz,+                          res+                          ) =+                            Data.Set.Internal.foldr+                              ( \f+                                 ( minH,+                                   acc+                                   ) -> case Symantic.Parser.Grammar.Combinators.unSomeFailure f of+                                    GHC.Maybe.Just (Symantic.Parser.Grammar.Combinators.FailureHorizon h :: Symantic.Parser.Grammar.Combinators.Failure (Symantic.Parser.Grammar.Combinators.CombSatisfiable (Symantic.Parser.Machine.Input.InputToken inp)))+                                      | GHC.Maybe.Just old <- minH ->+                                        ( GHC.Maybe.Just (GHC.Classes.min old h),+                                          acc+                                        )+                                      | GHC.Base.otherwise ->+                                        ( GHC.Maybe.Just h,+                                          acc+                                        )+                                    _ ->+                                      ( minH,+                                        f GHC.Types.: acc+                                      )+                              )+                              ( GHC.Maybe.Nothing,+                                GHC.Types . []+                              )+                              farExp+                     in Data.Set.Internal.fromList GHC.Base.$+                          ( case minHoriz of+                              GHC.Maybe.Just h -> Symantic.Parser.Grammar.Combinators.SomeFailure (Symantic.Parser.Grammar.Combinators.FailureHorizon @(Symantic.Parser.Machine.Input.InputToken inp) h) GHC.Types.: res+                              GHC.Maybe.Nothing -> res+                          )+                }+   in GHC.ST.runST+        ( let inputToken = Data.Proxy.Proxy :: Data.Proxy.Proxy (Symantic.Parser.Machine.Input.InputToken inp)+           in let inp = init+               in let readFail = finalRaise+                   in let _ = "checkHorizon.newCheck: checkedHorizon=0 minHoriz=2"+                       in if readMore (Symantic.Parser.Machine.Input.shiftRightText 1 inp)+                            then+                              let+                               in let _ = "pushValue"+                                   in let join = \farInp farExp v (!inp) ->+                                            let _ = "lift2Value checkedHorizon=0"+                                             in let _ = "resume"+                                                 in finalRet+                                                      farInp+                                                      farExp+                                                      ( let _ = "resume.genCode"+                                                         in GHC.Show.show v+                                                      )+                                                      inp+                                       in let _ = "catch ExceptionFailure checkedHorizon=2"+                                           in let onException =+                                                    let _ = "onException"+                                                     in \(!_exn) (!failInp) (!farInp) (!farExp) ->+                                                          let _ = "comment: raiseAgainIfConsumed"+                                                           in let _ = "saveInput checkedHorizon=0"+                                                               in let _ = "lift2Value checkedHorizon=0"+                                                                   in if ( \( Data.Text.Internal.Text+                                                                                _+                                                                                i+                                                                                _+                                                                              )+                                                                            ( Data.Text.Internal.Text+                                                                                _+                                                                                j+                                                                                _+                                                                              ) -> i GHC.Classes.== j+                                                                         )+                                                                        inp+                                                                        failInp+                                                                        then+                                                                          let _ = "choicesBranch checkedHorizon=0"+                                                                           in let _ = "catch ExceptionFailure checkedHorizon=0"+                                                                               in let onException =+                                                                                        let _ = "onException"+                                                                                         in \(!_exn) (!failInp) (!farInp) (!farExp) ->+                                                                                              let _ = "loadInput checkedHorizon=0"+                                                                                               in let _ = "checkHorizon.noCheck"+                                                                                                   in finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp farInp farExp+                                                                                   in let _ = "pushValue"+                                                                                       in let _ = "comment: satisfy ((GHC.Classes.==) 'a')"+                                                                                           in let inp = failInp+                                                                                               in let readFail = onException+                                                                                                   in let _ = "checkHorizon.newCheck: checkedHorizon=0 minHoriz=2"+                                                                                                       in if readMore (Symantic.Parser.Machine.Input.shiftRightText 1 inp)+                                                                                                            then+                                                                                                              let _ = "checkToken"+                                                                                                               in let !(#+                                                                                                                         c,+                                                                                                                         cs+                                                                                                                         #) = readNext inp+                                                                                                                   in if (GHC.Classes.==) 'a' c+                                                                                                                        then+                                                                                                                          let _ = "lift2Value checkedHorizon=2"+                                                                                                                           in let _ = "comment: satisfy ((GHC.Classes.==) 'b')"+                                                                                                                               in let _ = "checkHorizon.oldCheck: checkedHorizon=2"+                                                                                                                                   in let _ = "checkToken"+                                                                                                                                       in let !(#+                                                                                                                                                 c,+                                                                                                                                                 cs+                                                                                                                                                 #) = readNext cs+                                                                                                                                           in if (GHC.Classes.==) 'b' c+                                                                                                                                                then+                                                                                                                                                  let _ = "lift2Value checkedHorizon=1"+                                                                                                                                                   in let _ = "commit"+                                                                                                                                                       in let _ = "resume"+                                                                                                                                                           in join+                                                                                                                                                                farInp+                                                                                                                                                                farExp+                                                                                                                                                                ( let _ = "resume.genCode"+                                                                                                                                                                   in (GHC.Types.:) 'a' ((GHC.Types.:) 'b' GHC.Types . [])+                                                                                                                                                                )+                                                                                                                                                                cs+                                                                                                                                                else+                                                                                                                                                  let _ = "checkToken.fail"+                                                                                                                                                   in let failExp =+                                                                                                                                                            Data.Set.Internal.Bin+                                                                                                                                                              1+                                                                                                                                                              ( Symantic.Parser.Grammar.Combinators.SomeFailure+                                                                                                                                                                  ( case inputToken of+                                                                                                                                                                      (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken 'b'+                                                                                                                                                                  )+                                                                                                                                                              )+                                                                                                                                                              Data.Set.Internal.Tip+                                                                                                                                                              Data.Set.Internal.Tip+                                                                                                                                                       in let (#+                                                                                                                                                                farInp,+                                                                                                                                                                farExp+                                                                                                                                                                #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp cs of+                                                                                                                                                                  GHC.Types.LT ->+                                                                                                                                                                    (#+                                                                                                                                                                      cs,+                                                                                                                                                                      failExp+                                                                                                                                                                    #)+                                                                                                                                                                  GHC.Types.EQ ->+                                                                                                                                                                    (#+                                                                                                                                                                      farInp,+                                                                                                                                                                      failExp GHC.Base.<> farExp+                                                                                                                                                                    #)+                                                                                                                                                                  GHC.Types.GT ->+                                                                                                                                                                    (#+                                                                                                                                                                      farInp,+                                                                                                                                                                      farExp+                                                                                                                                                                    #)+                                                                                                                                                           in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure cs farInp farExp+                                                                                                                        else+                                                                                                                          let _ = "checkToken.fail"+                                                                                                                           in let failExp =+                                                                                                                                    Data.Set.Internal.Bin+                                                                                                                                      1+                                                                                                                                      ( Symantic.Parser.Grammar.Combinators.SomeFailure+                                                                                                                                          ( case inputToken of+                                                                                                                                              (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken 'a'+                                                                                                                                          )+                                                                                                                                      )+                                                                                                                                      Data.Set.Internal.Tip+                                                                                                                                      Data.Set.Internal.Tip+                                                                                                                               in let (#+                                                                                                                                        farInp,+                                                                                                                                        farExp+                                                                                                                                        #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp inp of+                                                                                                                                          GHC.Types.LT ->+                                                                                                                                            (#+                                                                                                                                              inp,+                                                                                                                                              failExp+                                                                                                                                            #)+                                                                                                                                          GHC.Types.EQ ->+                                                                                                                                            (#+                                                                                                                                              farInp,+                                                                                                                                              failExp GHC.Base.<> farExp+                                                                                                                                            #)+                                                                                                                                          GHC.Types.GT ->+                                                                                                                                            (#+                                                                                                                                              farInp,+                                                                                                                                              farExp+                                                                                                                                            #)+                                                                                                                                   in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp+                                                                                                            else+                                                                                                              let _ = "checkHorizon.newCheck.fail"+                                                                                                               in let failExp =+                                                                                                                        Data.Set.Internal.Bin+                                                                                                                          1+                                                                                                                          ( Symantic.Parser.Grammar.Combinators.SomeFailure+                                                                                                                              ( case inputToken of+                                                                                                                                  (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureHorizon @tok' 2+                                                                                                                              )+                                                                                                                          )+                                                                                                                          Data.Set.Internal.Tip+                                                                                                                          Data.Set.Internal.Tip+                                                                                                                   in let (#+                                                                                                                            farInp,+                                                                                                                            farExp+                                                                                                                            #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp inp of+                                                                                                                              GHC.Types.LT ->+                                                                                                                                (#+                                                                                                                                  inp,+                                                                                                                                  failExp+                                                                                                                                #)+                                                                                                                              GHC.Types.EQ ->+                                                                                                                                (#+                                                                                                                                  farInp,+                                                                                                                                  failExp GHC.Base.<> farExp+                                                                                                                                #)+                                                                                                                              GHC.Types.GT ->+                                                                                                                                (#+                                                                                                                                  farInp,+                                                                                                                                  farExp+                                                                                                                                #)+                                                                                                                       in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp+                                                                        else+                                                                          let _ = "choicesBranch.else"+                                                                           in finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp farInp farExp+                                               in let _ = "catch ExceptionFailure checkedHorizon=2"+                                                   in let onException =+                                                            let _ = "onException"+                                                             in \(!_exn) (!failInp) (!farInp) (!farExp) ->+                                                                  let _ = "loadInput checkedHorizon=2"+                                                                   in let _ = "checkHorizon.oldCheck: checkedHorizon=2"+                                                                       in onException Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp+                                                       in let _ = "pushValue"+                                                           in let _ = "comment: satisfy ((GHC.Classes.==) 'a')"+                                                               in let _ = "checkHorizon.oldCheck: checkedHorizon=2"+                                                                   in let _ = "checkToken"+                                                                       in let !(#+                                                                                 c,+                                                                                 cs+                                                                                 #) = readNext inp+                                                                           in if (GHC.Classes.==) 'a' c+                                                                                then+                                                                                  let _ = "lift2Value checkedHorizon=1"+                                                                                   in let _ = "comment: satisfy ((GHC.Classes.==) 'a')"+                                                                                       in let _ = "checkHorizon.oldCheck: checkedHorizon=1"+                                                                                           in let _ = "checkToken"+                                                                                               in let !(#+                                                                                                         c,+                                                                                                         cs+                                                                                                         #) = readNext cs+                                                                                                   in if (GHC.Classes.==) 'a' c+                                                                                                        then+                                                                                                          let _ = "lift2Value checkedHorizon=0"+                                                                                                           in let _ = "commit"+                                                                                                               in let _ = "commit"+                                                                                                                   in let _ = "resume"+                                                                                                                       in join+                                                                                                                            init+                                                                                                                            Data.Set.Internal.empty+                                                                                                                            ( let _ = "resume.genCode"+                                                                                                                               in (GHC.Types.:) 'a' ((GHC.Types.:) 'a' GHC.Types . [])+                                                                                                                            )+                                                                                                                            cs+                                                                                                        else+                                                                                                          let _ = "checkToken.fail"+                                                                                                           in let failExp =+                                                                                                                    Data.Set.Internal.Bin+                                                                                                                      1+                                                                                                                      ( Symantic.Parser.Grammar.Combinators.SomeFailure+                                                                                                                          ( case inputToken of+                                                                                                                              (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken 'a'+                                                                                                                          )+                                                                                                                      )+                                                                                                                      Data.Set.Internal.Tip+                                                                                                                      Data.Set.Internal.Tip+                                                                                                               in let (#+                                                                                                                        farInp,+                                                                                                                        farExp+                                                                                                                        #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init cs of+                                                                                                                          GHC.Types.LT ->+                                                                                                                            (#+                                                                                                                              cs,+                                                                                                                              failExp+                                                                                                                            #)+                                                                                                                          GHC.Types.EQ ->+                                                                                                                            (#+                                                                                                                              init,+                                                                                                                              failExp GHC.Base.<> Data.Set.Internal.empty+                                                                                                                            #)+                                                                                                                          GHC.Types.GT ->+                                                                                                                            (#+                                                                                                                              init,+                                                                                                                              Data.Set.Internal.empty+                                                                                                                            #)+                                                                                                                   in onException Symantic.Parser.Grammar.Combinators.ExceptionFailure cs farInp farExp+                                                                                else+                                                                                  let _ = "checkToken.fail"+                                                                                   in let failExp =+                                                                                            Data.Set.Internal.Bin+                                                                                              1+                                                                                              ( Symantic.Parser.Grammar.Combinators.SomeFailure+                                                                                                  ( case inputToken of+                                                                                                      (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken 'a'+                                                                                                  )+                                                                                              )+                                                                                              Data.Set.Internal.Tip+                                                                                              Data.Set.Internal.Tip+                                                                                       in let (#+                                                                                                farInp,+                                                                                                farExp+                                                                                                #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init inp of+                                                                                                  GHC.Types.LT ->+                                                                                                    (#+                                                                                                      inp,+                                                                                                      failExp+                                                                                                    #)+                                                                                                  GHC.Types.EQ ->+                                                                                                    (#+                                                                                                      init,+                                                                                                      failExp GHC.Base.<> Data.Set.Internal.empty+                                                                                                    #)+                                                                                                  GHC.Types.GT ->+                                                                                                    (#+                                                                                                      init,+                                                                                                      Data.Set.Internal.empty+                                                                                                    #)+                                                                                           in onException Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp+                            else+                              let _ = "checkHorizon.newCheck.fail"+                               in let failExp =+                                        Data.Set.Internal.Bin+                                          1+                                          ( Symantic.Parser.Grammar.Combinators.SomeFailure+                                              ( case inputToken of+                                                  (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureHorizon @tok' 2+                                              )+                                          )+                                          Data.Set.Internal.Tip+                                          Data.Set.Internal.Tip+                                   in let (#+                                            farInp,+                                            farExp+                                            #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init inp of+                                              GHC.Types.LT ->+                                                (#+                                                  inp,+                                                  failExp+                                                #)+                                              GHC.Types.EQ ->+                                                (#+                                                  init,+                                                  failExp GHC.Base.<> Data.Set.Internal.empty+                                                #)+                                              GHC.Types.GT ->+                                                (#+                                                  init,+                                                  Data.Set.Internal.empty+                                                #)+                                       in finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp+        )
+ tests/Golden/Splice/G8.expected.txt view
@@ -0,0 +1,342 @@+\(input :: inp) ->+  let !(#+         init,+         readMore,+         readNext+         #) =+          let _ = "cursorOf"+           in let next+                    ( t@( Data.Text.Internal.Text+                            arr+                            off+                            unconsumed+                          )+                      ) =+                      let !( Data.Text.Unsafe.Iter+                               c+                               d+                             ) = Data.Text.Unsafe.iter t 0+                       in (#+                            c,+                            Data.Text.Internal.Text arr (off GHC.Num.+ d) (unconsumed GHC.Num.- d)+                          #)+                  more+                    ( Data.Text.Internal.Text+                        _+                        _+                        unconsumed+                      ) = unconsumed GHC.Classes.> 0+               in (# input, more, next #)+      finalRet = \_farInp _farExp v _inp -> Symantic.Parser.Machine.Generate.returnST GHC.Base.$ Data.Either.Right v+      finalRaise ::+        forall st b.+        Symantic.Parser.Machine.Generate.OnException+          st+          inp+          b = \(!exn) _failInp (!farInp) (!farExp) ->+          Symantic.Parser.Machine.Generate.returnST GHC.Base.$+            Data.Either.Left+              Symantic.Parser.Machine.Generate.ParsingError+                { Symantic.Parser.Machine.Generate.parsingErrorOffset = Symantic.Parser.Machine.Input.offset farInp,+                  Symantic.Parser.Machine.Generate.parsingErrorException = exn,+                  Symantic.Parser.Machine.Generate.parsingErrorUnexpected =+                    if readMore farInp+                      then+                        GHC.Maybe.Just+                          ( let (#+                                  c,+                                  _+                                  #) = readNext farInp+                             in c+                          )+                      else GHC.Maybe.Nothing,+                  Symantic.Parser.Machine.Generate.parsingErrorExpecting =+                    let ( minHoriz,+                          res+                          ) =+                            Data.Set.Internal.foldr+                              ( \f+                                 ( minH,+                                   acc+                                   ) -> case Symantic.Parser.Grammar.Combinators.unSomeFailure f of+                                    GHC.Maybe.Just (Symantic.Parser.Grammar.Combinators.FailureHorizon h :: Symantic.Parser.Grammar.Combinators.Failure (Symantic.Parser.Grammar.Combinators.CombSatisfiable (Symantic.Parser.Machine.Input.InputToken inp)))+                                      | GHC.Maybe.Just old <- minH ->+                                        ( GHC.Maybe.Just (GHC.Classes.min old h),+                                          acc+                                        )+                                      | GHC.Base.otherwise ->+                                        ( GHC.Maybe.Just h,+                                          acc+                                        )+                                    _ ->+                                      ( minH,+                                        f GHC.Types.: acc+                                      )+                              )+                              ( GHC.Maybe.Nothing,+                                GHC.Types . []+                              )+                              farExp+                     in Data.Set.Internal.fromList GHC.Base.$+                          ( case minHoriz of+                              GHC.Maybe.Just h -> Symantic.Parser.Grammar.Combinators.SomeFailure (Symantic.Parser.Grammar.Combinators.FailureHorizon @(Symantic.Parser.Machine.Input.InputToken inp) h) GHC.Types.: res+                              GHC.Maybe.Nothing -> res+                          )+                }+   in GHC.ST.runST+        ( let inputToken = Data.Proxy.Proxy :: Data.Proxy.Proxy (Symantic.Parser.Machine.Input.InputToken inp)+           in let _ = "checkHorizon.noCheck"+               in let+                   in let _ = "pushValue"+                       in let _ = "pushValue"+                           in do+                                let dupv = \x -> x+                                reg <- GHC.STRef.newSTRef dupv+                                let _ = "iter"+                                 in let onException loopInput =+                                          let _ = "onException"+                                           in \(!_exn) (!failInp) (!farInp) (!farExp) ->+                                                let _ = "comment: raiseAgainIfConsumed"+                                                 in let _ = "saveInput checkedHorizon=0"+                                                     in let _ = "lift2Value checkedHorizon=0"+                                                         in if ( \( Data.Text.Internal.Text+                                                                      _+                                                                      i+                                                                      _+                                                                    )+                                                                  ( Data.Text.Internal.Text+                                                                      _+                                                                      j+                                                                      _+                                                                    ) -> i GHC.Classes.== j+                                                               )+                                                              loopInput+                                                              failInp+                                                              then+                                                                let _ = "choicesBranch checkedHorizon=0"+                                                                 in do+                                                                      sr <- GHC.STRef.readSTRef reg+                                                                      let _ = "pushValue"+                                                                       in let _ = "lift2Value checkedHorizon=0"+                                                                           in let _ = "lift2Value checkedHorizon=0"+                                                                               in let join = \farInp farExp v (!inp) ->+                                                                                        let _ = "lift2Value checkedHorizon=0"+                                                                                         in let _ = "resume"+                                                                                             in finalRet+                                                                                                  farInp+                                                                                                  farExp+                                                                                                  ( let _ = "resume.genCode"+                                                                                                     in GHC.Show.show (sr GHC.Types . [])+                                                                                                  )+                                                                                                  inp+                                                                                   in let _ = "catch ExceptionFailure checkedHorizon=0"+                                                                                       in let onException =+                                                                                                let _ = "onException"+                                                                                                 in \(!_exn) (!failInp) (!farInp) (!farExp) ->+                                                                                                      let _ = "comment: raiseAgainIfConsumed"+                                                                                                       in let _ = "saveInput checkedHorizon=0"+                                                                                                           in let _ = "lift2Value checkedHorizon=0"+                                                                                                               in if ( \( Data.Text.Internal.Text+                                                                                                                            _+                                                                                                                            i+                                                                                                                            _+                                                                                                                          )+                                                                                                                        ( Data.Text.Internal.Text+                                                                                                                            _+                                                                                                                            j+                                                                                                                            _+                                                                                                                          ) -> i GHC.Classes.== j+                                                                                                                     )+                                                                                                                    failInp+                                                                                                                    failInp+                                                                                                                    then+                                                                                                                      let _ = "choicesBranch checkedHorizon=0"+                                                                                                                       in let _ = "comment: eof.fail"+                                                                                                                           in let failExp = Data.Set.Internal.Bin 1 (Symantic.Parser.Grammar.Combinators.SomeFailure Symantic.Parser.Grammar.Combinators.FailureEnd) Data.Set.Internal.Tip Data.Set.Internal.Tip+                                                                                                                               in let (#+                                                                                                                                        farInp,+                                                                                                                                        farExp+                                                                                                                                        #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp failInp of+                                                                                                                                          GHC.Types.LT ->+                                                                                                                                            (#+                                                                                                                                              failInp,+                                                                                                                                              failExp+                                                                                                                                            #)+                                                                                                                                          GHC.Types.EQ ->+                                                                                                                                            (#+                                                                                                                                              farInp,+                                                                                                                                              failExp GHC.Base.<> farExp+                                                                                                                                            #)+                                                                                                                                          GHC.Types.GT ->+                                                                                                                                            (#+                                                                                                                                              farInp,+                                                                                                                                              farExp+                                                                                                                                            #)+                                                                                                                                   in finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp farInp farExp+                                                                                                                    else+                                                                                                                      let _ = "choicesBranch.else"+                                                                                                                       in finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp farInp farExp+                                                                                           in let _ = "comment: negLook"+                                                                                               in let _ = "catch ExceptionFailure checkedHorizon=0"+                                                                                                   in let onException =+                                                                                                            let _ = "onException"+                                                                                                             in \(!_exn) (!failInp) (!farInp) (!farExp) ->+                                                                                                                  let _ = "comment: negLook.reset"+                                                                                                                   in let _ = "loadInput checkedHorizon=0"+                                                                                                                       in let _ = "checkHorizon.noCheck"+                                                                                                                           in let _ = "pushValue"+                                                                                                                               in let _ = "commit"+                                                                                                                                   in let _ = "resume"+                                                                                                                                       in join+                                                                                                                                            farInp+                                                                                                                                            farExp+                                                                                                                                            ( let _ = "resume.genCode"+                                                                                                                                               in GHC.Tuple . ()+                                                                                                                                            )+                                                                                                                                            failInp+                                                                                                       in let _ = "comment: negLook.ahead"+                                                                                                           in let _ = "saveInput checkedHorizon=0"+                                                                                                               in let _ = "comment: satisfy ((\\x_0 -> \\x_1 -> x_0) GHC.Types.True)"+                                                                                                                   in let inp = failInp+                                                                                                                       in let readFail = onException+                                                                                                                           in let _ = "checkHorizon.newCheck: checkedHorizon=0 minHoriz=1"+                                                                                                                               in if readMore inp+                                                                                                                                    then+                                                                                                                                      let _ = "checkToken"+                                                                                                                                       in let !(#+                                                                                                                                                 c,+                                                                                                                                                 cs+                                                                                                                                                 #) = readNext inp+                                                                                                                                           in let _ = "popValue"+                                                                                                                                               in let _ = "commit"+                                                                                                                                                   in let _ = "loadInput checkedHorizon=0"+                                                                                                                                                       in let _ = "checkHorizon.noCheck"+                                                                                                                                                           in onException Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp farInp farExp+                                                                                                                                    else+                                                                                                                                      let _ = "checkHorizon.newCheck.fail"+                                                                                                                                       in let failExp =+                                                                                                                                                Data.Set.Internal.Bin+                                                                                                                                                  1+                                                                                                                                                  ( Symantic.Parser.Grammar.Combinators.SomeFailure+                                                                                                                                                      ( case inputToken of+                                                                                                                                                          (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureHorizon @tok' 1+                                                                                                                                                      )+                                                                                                                                                  )+                                                                                                                                                  Data.Set.Internal.Tip+                                                                                                                                                  Data.Set.Internal.Tip+                                                                                                                                           in let (#+                                                                                                                                                    farInp,+                                                                                                                                                    farExp+                                                                                                                                                    #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp inp of+                                                                                                                                                      GHC.Types.LT ->+                                                                                                                                                        (#+                                                                                                                                                          inp,+                                                                                                                                                          failExp+                                                                                                                                                        #)+                                                                                                                                                      GHC.Types.EQ ->+                                                                                                                                                        (#+                                                                                                                                                          farInp,+                                                                                                                                                          failExp GHC.Base.<> farExp+                                                                                                                                                        #)+                                                                                                                                                      GHC.Types.GT ->+                                                                                                                                                        (#+                                                                                                                                                          farInp,+                                                                                                                                                          farExp+                                                                                                                                                        #)+                                                                                                                                               in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp+                                                              else+                                                                let _ = "choicesBranch.else"+                                                                 in finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp farInp farExp+                                        loop = \_callerOnReturn callerInput callerOnExceptionStackByLabel ->+                                          let _ = "pushValue"+                                           in let _ = "comment: satisfy ((GHC.Classes.==) 'r')"+                                               in let inp = callerInput+                                                   in let readFail = onException callerInput+                                                       in let _ = "checkHorizon.newCheck: checkedHorizon=0 minHoriz=1"+                                                           in if readMore inp+                                                                then+                                                                  let _ = "checkToken"+                                                                   in let !(#+                                                                             c,+                                                                             cs+                                                                             #) = readNext inp+                                                                       in if (GHC.Classes.==) 'r' c+                                                                            then+                                                                              let _ = "lift2Value checkedHorizon=1"+                                                                               in let _ = "pushValue"+                                                                                   in let _ = "lift2Value checkedHorizon=1"+                                                                                       in do+                                                                                            sr <- GHC.STRef.readSTRef reg+                                                                                            let _ = "lift2Value checkedHorizon=1"+                                                                                             in do+                                                                                                  let dupv = \x -> sr ((GHC.Types.:) 'r' x)+                                                                                                  GHC.STRef.writeSTRef reg dupv+                                                                                                  let _ = "jump"+                                                                                                   in loop (GHC.Err.error "invalid onReturn") cs (Data.Map.Internal.Bin 1 Symantic.Parser.Grammar.Combinators.ExceptionFailure readFail Data.Map.Internal.Tip Data.Map.Internal.Tip)+                                                                            else+                                                                              let _ = "checkToken.fail"+                                                                               in let failExp =+                                                                                        Data.Set.Internal.Bin+                                                                                          1+                                                                                          ( Symantic.Parser.Grammar.Combinators.SomeFailure+                                                                                              ( case inputToken of+                                                                                                  (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken 'r'+                                                                                              )+                                                                                          )+                                                                                          Data.Set.Internal.Tip+                                                                                          Data.Set.Internal.Tip+                                                                                   in let (#+                                                                                            farInp,+                                                                                            farExp+                                                                                            #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init inp of+                                                                                              GHC.Types.LT ->+                                                                                                (#+                                                                                                  inp,+                                                                                                  failExp+                                                                                                #)+                                                                                              GHC.Types.EQ ->+                                                                                                (#+                                                                                                  init,+                                                                                                  failExp GHC.Base.<> Data.Set.Internal.empty+                                                                                                #)+                                                                                              GHC.Types.GT ->+                                                                                                (#+                                                                                                  init,+                                                                                                  Data.Set.Internal.empty+                                                                                                #)+                                                                                       in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp+                                                                else+                                                                  let _ = "checkHorizon.newCheck.fail"+                                                                   in let failExp =+                                                                            Data.Set.Internal.Bin+                                                                              1+                                                                              ( Symantic.Parser.Grammar.Combinators.SomeFailure+                                                                                  ( case inputToken of+                                                                                      (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureHorizon @tok' 1+                                                                                  )+                                                                              )+                                                                              Data.Set.Internal.Tip+                                                                              Data.Set.Internal.Tip+                                                                       in let (#+                                                                                farInp,+                                                                                farExp+                                                                                #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init inp of+                                                                                  GHC.Types.LT ->+                                                                                    (#+                                                                                      inp,+                                                                                      failExp+                                                                                    #)+                                                                                  GHC.Types.EQ ->+                                                                                    (#+                                                                                      init,+                                                                                      failExp GHC.Base.<> Data.Set.Internal.empty+                                                                                    #)+                                                                                  GHC.Types.GT ->+                                                                                    (#+                                                                                      init,+                                                                                      Data.Set.Internal.empty+                                                                                    #)+                                                                           in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp+                                     in let _ = "jump"+                                         in loop finalRet init Data.Map.Internal.Tip+        )
+ tests/Golden/Splice/G9.expected.txt view
@@ -0,0 +1,216 @@+\(input :: inp) ->+  let !(#+         init,+         readMore,+         readNext+         #) =+          let _ = "cursorOf"+           in let next+                    ( t@( Data.Text.Internal.Text+                            arr+                            off+                            unconsumed+                          )+                      ) =+                      let !( Data.Text.Unsafe.Iter+                               c+                               d+                             ) = Data.Text.Unsafe.iter t 0+                       in (#+                            c,+                            Data.Text.Internal.Text arr (off GHC.Num.+ d) (unconsumed GHC.Num.- d)+                          #)+                  more+                    ( Data.Text.Internal.Text+                        _+                        _+                        unconsumed+                      ) = unconsumed GHC.Classes.> 0+               in (# input, more, next #)+      finalRet = \_farInp _farExp v _inp -> Symantic.Parser.Machine.Generate.returnST GHC.Base.$ Data.Either.Right v+      finalRaise ::+        forall st b.+        Symantic.Parser.Machine.Generate.OnException+          st+          inp+          b = \(!exn) _failInp (!farInp) (!farExp) ->+          Symantic.Parser.Machine.Generate.returnST GHC.Base.$+            Data.Either.Left+              Symantic.Parser.Machine.Generate.ParsingError+                { Symantic.Parser.Machine.Generate.parsingErrorOffset = Symantic.Parser.Machine.Input.offset farInp,+                  Symantic.Parser.Machine.Generate.parsingErrorException = exn,+                  Symantic.Parser.Machine.Generate.parsingErrorUnexpected =+                    if readMore farInp+                      then+                        GHC.Maybe.Just+                          ( let (#+                                  c,+                                  _+                                  #) = readNext farInp+                             in c+                          )+                      else GHC.Maybe.Nothing,+                  Symantic.Parser.Machine.Generate.parsingErrorExpecting =+                    let ( minHoriz,+                          res+                          ) =+                            Data.Set.Internal.foldr+                              ( \f+                                 ( minH,+                                   acc+                                   ) -> case Symantic.Parser.Grammar.Combinators.unSomeFailure f of+                                    GHC.Maybe.Just (Symantic.Parser.Grammar.Combinators.FailureHorizon h :: Symantic.Parser.Grammar.Combinators.Failure (Symantic.Parser.Grammar.Combinators.CombSatisfiable (Symantic.Parser.Machine.Input.InputToken inp)))+                                      | GHC.Maybe.Just old <- minH ->+                                        ( GHC.Maybe.Just (GHC.Classes.min old h),+                                          acc+                                        )+                                      | GHC.Base.otherwise ->+                                        ( GHC.Maybe.Just h,+                                          acc+                                        )+                                    _ ->+                                      ( minH,+                                        f GHC.Types.: acc+                                      )+                              )+                              ( GHC.Maybe.Nothing,+                                GHC.Types . []+                              )+                              farExp+                     in Data.Set.Internal.fromList GHC.Base.$+                          ( case minHoriz of+                              GHC.Maybe.Just h -> Symantic.Parser.Grammar.Combinators.SomeFailure (Symantic.Parser.Grammar.Combinators.FailureHorizon @(Symantic.Parser.Machine.Input.InputToken inp) h) GHC.Types.: res+                              GHC.Maybe.Nothing -> res+                          )+                }+   in GHC.ST.runST+        ( let inputToken = Data.Proxy.Proxy :: Data.Proxy.Proxy (Symantic.Parser.Machine.Input.InputToken inp)+           in let _ = "checkHorizon.noCheck"+               in let+                   in let _ = "pushValue"+                       in let join = \farInp farExp v (!inp) ->+                                let _ = "lift2Value checkedHorizon=0"+                                 in let _ = "resume"+                                     in finalRet+                                          farInp+                                          farExp+                                          ( let _ = "resume.genCode"+                                             in GHC.Show.show v+                                          )+                                          inp+                           in let _ = "catch ExceptionFailure checkedHorizon=0"+                               in let onException =+                                        let _ = "onException"+                                         in \(!_exn) (!failInp) (!farInp) (!farExp) ->+                                              let _ = "comment: raiseAgainIfConsumed"+                                               in let _ = "saveInput checkedHorizon=0"+                                                   in let _ = "lift2Value checkedHorizon=0"+                                                       in if ( \( Data.Text.Internal.Text+                                                                    _+                                                                    i+                                                                    _+                                                                  )+                                                                ( Data.Text.Internal.Text+                                                                    _+                                                                    j+                                                                    _+                                                                  ) -> i GHC.Classes.== j+                                                             )+                                                            init+                                                            failInp+                                                            then+                                                              let _ = "choicesBranch checkedHorizon=0"+                                                               in let _ = "comment: eof.fail"+                                                                   in let failExp = Data.Set.Internal.Bin 1 (Symantic.Parser.Grammar.Combinators.SomeFailure Symantic.Parser.Grammar.Combinators.FailureEnd) Data.Set.Internal.Tip Data.Set.Internal.Tip+                                                                       in let (#+                                                                                farInp,+                                                                                farExp+                                                                                #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) farInp failInp of+                                                                                  GHC.Types.LT ->+                                                                                    (#+                                                                                      failInp,+                                                                                      failExp+                                                                                    #)+                                                                                  GHC.Types.EQ ->+                                                                                    (#+                                                                                      farInp,+                                                                                      failExp GHC.Base.<> farExp+                                                                                    #)+                                                                                  GHC.Types.GT ->+                                                                                    (#+                                                                                      farInp,+                                                                                      farExp+                                                                                    #)+                                                                           in finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp farInp farExp+                                                            else+                                                              let _ = "choicesBranch.else"+                                                               in finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure failInp farInp farExp+                                   in let _ = "comment: negLook"+                                       in let _ = "catch ExceptionFailure checkedHorizon=0"+                                           in let onException =+                                                    let _ = "onException"+                                                     in \(!_exn) (!failInp) (!farInp) (!farExp) ->+                                                          let _ = "comment: negLook.reset"+                                                           in let _ = "loadInput checkedHorizon=0"+                                                               in let _ = "checkHorizon.noCheck"+                                                                   in let _ = "pushValue"+                                                                       in let _ = "commit"+                                                                           in let _ = "resume"+                                                                               in join+                                                                                    farInp+                                                                                    farExp+                                                                                    ( let _ = "resume.genCode"+                                                                                       in GHC.Tuple . ()+                                                                                    )+                                                                                    init+                                               in let _ = "comment: negLook.ahead"+                                                   in let _ = "saveInput checkedHorizon=0"+                                                       in let _ = "comment: satisfy ((\\x_0 -> \\x_1 -> x_0) GHC.Types.True)"+                                                           in let inp = init+                                                               in let readFail = onException+                                                                   in let _ = "checkHorizon.newCheck: checkedHorizon=0 minHoriz=1"+                                                                       in if readMore inp+                                                                            then+                                                                              let _ = "checkToken"+                                                                               in let !(#+                                                                                         c,+                                                                                         cs+                                                                                         #) = readNext inp+                                                                                   in let _ = "popValue"+                                                                                       in let _ = "commit"+                                                                                           in let _ = "loadInput checkedHorizon=0"+                                                                                               in let _ = "checkHorizon.noCheck"+                                                                                                   in onException Symantic.Parser.Grammar.Combinators.ExceptionFailure init init Data.Set.Internal.empty+                                                                            else+                                                                              let _ = "checkHorizon.newCheck.fail"+                                                                               in let failExp =+                                                                                        Data.Set.Internal.Bin+                                                                                          1+                                                                                          ( Symantic.Parser.Grammar.Combinators.SomeFailure+                                                                                              ( case inputToken of+                                                                                                  (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureHorizon @tok' 1+                                                                                              )+                                                                                          )+                                                                                          Data.Set.Internal.Tip+                                                                                          Data.Set.Internal.Tip+                                                                                   in let (#+                                                                                            farInp,+                                                                                            farExp+                                                                                            #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init inp of+                                                                                              GHC.Types.LT ->+                                                                                                (#+                                                                                                  inp,+                                                                                                  failExp+                                                                                                #)+                                                                                              GHC.Types.EQ ->+                                                                                                (#+                                                                                                  init,+                                                                                                  failExp GHC.Base.<> Data.Set.Internal.empty+                                                                                                #)+                                                                                              GHC.Types.GT ->+                                                                                                (#+                                                                                                  init,+                                                                                                  Data.Set.Internal.empty+                                                                                                #)+                                                                                       in readFail Symantic.Parser.Grammar.Combinators.ExceptionFailure inp farInp farExp+        )
+ tests/Golden/Utils.hs view
@@ -0,0 +1,36 @@+module Golden.Utils where++import Control.Monad (Monad(..))+import Data.Either (Either(..))+import Data.Function (($))+import Data.Semigroup (Semigroup(..))+import Data.String (String)+import System.IO (IO, FilePath)+import System.IO.Unsafe (unsafePerformIO)+import qualified Data.ByteString.Lazy as BSL+import qualified Data.IORef as IORef++import qualified Data.Text.Lazy as TL+import qualified Data.Text.Lazy.Encoding as TL+import qualified Language.Haskell.TH.Syntax as TH+import Paths_symantic_parser++getGoldenDir :: FilePath -> FilePath+getGoldenDir p = unsafePerformIO $ getDataFileName $ "tests/Golden/" <> p++goldenDiff :: FilePath -> FilePath -> [String]+goldenDiff ref new = ["diff", "-u", "-w", "-B", ref, new]++-- | Resetting 'TH.counter' makes 'makeLetName' deterministic,+-- except when GHC or executable flags change, like profiling+-- or even --accept unfortunately,+-- in those case the golden tests may fail+-- due to a different numbering of the 'ref' combinators.+-- Hence 'ShowLetName' is used with 'False' there.+resetTHNameCounter :: IO ()+resetTHNameCounter = IORef.writeIORef TH.counter 0++unLeft :: Either String BSL.ByteString -> IO BSL.ByteString+unLeft lr = case lr of+  Left err -> return $ TL.encodeUtf8 $ TL.pack err+  Right a  -> return a
+ tests/Grammar.hs view
@@ -0,0 +1,71 @@+{-# LANGUAGE FlexibleContexts #-}+{-# LANGUAGE NoMonomorphismRestriction #-}+{-# LANGUAGE TypeApplications #-}+{-# LANGUAGE TypeFamilies #-}+{-# LANGUAGE TemplateHaskell #-}+{-# OPTIONS_GHC -Wno-missing-signatures #-}+module Grammar where+import Data.Char (Char)+import Data.Function (($))+import Data.String (String)+import Text.Show (Show(..))+import qualified Data.Functor as Functor+import qualified Parsers.Nandlang+import qualified Parsers.Brainfuck.SymanticParser.Grammar+import qualified Language.Haskell.TH.Syntax as TH++import Symantic.Parser++rawGrammars :: Grammarable Char repr => [ObserveSharing TH.Name repr String]+rawGrammars =+  [ production show [||show||] <$> g1+  , production show [||show||] <$> g2+  , production show [||show||] <$> g3+  , production show [||show||] <$> g4+  , production show [||show||] <$> g5+  , production show [||show||] <$> g6+  , production show [||show||] <$> g7+  , production show [||show||] <$> g8+  , production show [||show||] <$> g9+  , production show [||show||] <$> g10+  , production show [||show||] <$> g11+  , production show [||show||] <$> g12+  , production show [||show||] <$> g13+  , production show [||show||] <$> g14+  , production show [||show||] <$> g15+  , production show [||show||] <$> g16+  , production show [||show||] <$> g17+  , production show [||show||] <$> g18+  , production show [||show||] <$> g19+  , production show [||show||] <$> g20+  ]+grammars :: Grammarable Char repr => [repr String]+grammars = (Functor.<$> rawGrammars) $ \g ->+  observeSharing g++g1 = char 'a'+g2 = string "abc"+g3 = many (char 'a')+g4 = some (string "abcd")+g5 = some (string "abcd") <* eof+g6 = traverse char "aa" <|> traverse char "ab"+g7 = string "aa" <|> string "ab"+g8 = many (char 'r') <* eof+g9 = eof+g10 = char 'a' <|> char 'b'+g11 = many (char 'a') <* char 'b'+g12 = many (oneOf ['a', 'b', 'c', 'd']) <* eof+g13 = Parsers.Brainfuck.SymanticParser.Grammar.grammar @Char @_+g14 = Parsers.Nandlang.grammar+g15 = (char 'a' <|> char 'b') <* char 'c'+g16 = (char 'a' <|> char 'b' <|> char 'c') <* char 'd'+g17 ::+  CombApplicable repr =>+  CombSatisfiable Char repr =>+  CombRegisterableUnscoped repr =>+  Referenceable TH.Name repr =>+  ObserveSharing TH.Name repr (Char, Char)+g17 = bind (item @Char) (\pc -> production (,) [||(,)||] <$> pc <*> pc)+g18 = string "abc" <|> string "de"+g19 = (string "abc" <|> string "de") <|> string "fghi"+g20 = (tokens "abc" <|> tokens "") *> void (tokens "def")
+ tests/Main.hs view
@@ -0,0 +1,15 @@+module Main where++import System.IO (IO)+import Test.Tasty+import Golden+--import HUnit++main :: IO ()+main = do+  defaultMain (+    testGroup ""+      [ Golden.goldens+      --, hunits+      ]+    )